home *** CD-ROM | disk | FTP | other *** search
/ CD World Haziran 1997 / CD World Haziran 1997.iso / Programlama ve Gelistirme / DTime / _SETUP.1 / Datetime.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-11-04  |  101.9 KB  |  4,198 lines
  1. /*
  2. Module : DATETIME.H
  3. Purpose: Implementation for a number of Date / Time classes
  4. Created: PJN / DATE/1 / 05-05-1995
  5. History: None
  6.  
  7. Copyright (c) 1995 by PJ Naughter.  
  8. All rights reserved.
  9.  
  10. */
  11.  
  12. /////////////////////////////////  Includes  //////////////////////////////////
  13. #include "stdafx.h"
  14. #include "limits.h"
  15. #include "time.h"
  16. #include "stdlib.h"
  17. #include "math.h"                                      
  18. #include "float.h"
  19. #include "datetime.h"
  20. #include "resource.h"
  21.  
  22.  
  23.  
  24. //////////////////////////////////  Macros  ///////////////////////////////////
  25. IMPLEMENT_SERIAL(CDate, CObject, VERSIONABLE_SCHEMA|1)
  26. IMPLEMENT_SERIAL(CLTimeSpan, CObject, VERSIONABLE_SCHEMA|1)
  27. IMPLEMENT_SERIAL(CLTimeOfDay, CObject, VERSIONABLE_SCHEMA|1)
  28. IMPLEMENT_SERIAL(CLDate, CObject, VERSIONABLE_SCHEMA|1)
  29.  
  30.  
  31.  
  32. #ifdef _DEBUG
  33. #undef THIS_FILE
  34. static char BASED_CODE THIS_FILE[] = __FILE__;
  35. #define new DEBUG_NEW
  36. #endif
  37.  
  38.  
  39. ////////////////////////////////// Locals /////////////////////////////////////
  40. LONG lfloor(LONG a, LONG b);
  41. void SetFebLength(BOOL bIsLeap);
  42. void ResetFebLength();
  43. long WeekOfDayModulo(long x, long y);
  44.  
  45.  
  46.  
  47. ////////////////////////////////// Statics ////////////////////////////////////
  48.  
  49. BOOL CDate::sm_bDoAsserts       = TRUE;
  50. LONG CDate::sm_lEndJulianYear  = 1582;
  51. WORD CDate::sm_wEndJulianMonth = 10;
  52. WORD CDate::sm_wEndJulianDay   = 4;
  53. LONG CDate::sm_lBeginGregYear  = 1582;
  54. WORD CDate::sm_wBeginGregMonth = 10; 
  55. WORD CDate::sm_wBeginGregDay   = 15;
  56. CString CDate::sm_sDefaultFormat = _T("%d/%m/%Y");
  57.  
  58. BOOL CLTimeSpan::sm_bDoAsserts  = TRUE;
  59. CString CLTimeSpan::sm_sDefaultFormat = _T("%D %H:%M:%S");
  60. CString CLTimeSpan::sm_sDefaultFormatNOS = _T("%H:%M"); 
  61.  
  62. BOOL CLTimeOfDay::sm_bDoAsserts = TRUE;   
  63. CString CLTimeOfDay::sm_sDefaultFormat = _T("%H:%M:%S"); 
  64. CString CLTimeOfDay::sm_sDefaultFormatNOS = _T("%H:%M"); 
  65.  
  66. BOOL CLDate::sm_bDoAsserts      = TRUE;
  67. BOOL CLDate::sm_bIsDst          = TRUE;
  68.  
  69.  
  70.  
  71.  
  72. static const int DeltaTTable[187] =
  73.  {1240, 1150, 1060, 980, 910, 850, 790, 740, 700, 650,
  74.   620, 580, 550, 530, 500, 480, 460, 440, 420, 400, 
  75.   370, 350, 330, 310, 280, 260, 240, 220, 200, 180, 
  76.   160, 140, 130, 120, 110, 100,  90,  90,  90,  90, 
  77.    90,  90,  90,  90, 100, 100, 100, 100, 100, 110, 
  78.   110, 110, 110, 110, 110, 110, 110, 120, 120, 120,
  79.   120, 120, 130, 130, 130, 130, 140, 140, 140, 150,
  80.   150, 150, 150, 160, 160, 160, 160, 160, 170, 170,
  81.   170, 170, 170, 170, 170, 170, 160, 160, 150, 140,
  82.   137, 131, 127, 125, 125, 125, 125, 125, 125, 123,
  83.   120, 114, 106,  96,  86,  75,  66,  60,  57,  56, 
  84.    57,  59,  62,  65,  68,  71,  73,  75,  77,  78,
  85.    79,  75,  64,  54,  29,  16, -10, -27, -36, -47,
  86.   -54, -52, -55, -56, -58, -59, -62, -64, -61, -47,
  87.   -27,   0,  26,  54,  77, 105, 134, 160, 182, 202,
  88.   212, 224, 235, 239, 243, 240, 239, 239, 237, 240,
  89.   243, 253, 262, 273, 282, 291, 300, 307, 314, 322,
  90.   331, 340, 350, 365, 383, 402, 422, 445, 465, 485,
  91.   505, 522, 538, 549, 558, 569, 580};
  92.  
  93. static WORD MonthLength[14] =
  94.   {
  95.   0,  31, 28, 31, 30, 31, 30,
  96.   31, 31, 30, 31, 30, 31, 0};
  97.  
  98.  
  99.  
  100.  
  101. ////////////////////////////////// Implementation /////////////////////////////
  102.             
  103.  
  104.  
  105. //Free Sub-Programs
  106.  
  107. long WeekOfDayModulo(long x, long y)
  108. {
  109.   if (x >= 0)
  110.     return x % y;
  111.   else
  112.   {
  113.     return (y - labs(x % y)) % y;
  114.   }
  115. }
  116.  
  117.  
  118. void SetFebLength(BOOL bIsLeap)
  119. {
  120.   MonthLength[2] = (WORD) (28 + bIsLeap);
  121. }
  122.  
  123. void ResetFebLength()
  124. {
  125.   MonthLength[2] = 28;
  126. };
  127.  
  128. LONG lfloor(LONG a, LONG b)
  129. {
  130.   ASSERT(b > 0);
  131.   return (a >= 0L ? a/b : (a%b == 0L) - 1 - labs(a)/b);
  132. }
  133.  
  134. void InitDTime()
  135. {
  136.   CDate::InitCalendarSettings();
  137.   CDate::GetDefaultFormat();
  138.   CLTimeSpan::GetDefaultFormat();
  139.   CLTimeOfDay::GetDefaultFormat();
  140. }
  141.  
  142.  
  143.  
  144. //CDate Implementation
  145.  
  146. CDate::CDate()
  147. {
  148.   Set();
  149. }
  150.  
  151. CDate::CDate(LONG Year, WORD Month, WORD Day)
  152. { 
  153.   Set(Year, Month, Day);
  154. }
  155.  
  156. CDate::CDate(const SYSTEMTIME& st)
  157. {
  158.   Set(st);
  159. }
  160.  
  161. CDate::CDate(LONG Year, WORD Month, WORD WeekOfMonth, WORD DayOfWeek)
  162. {
  163.   Set(Year, Month, WeekOfMonth, DayOfWeek);
  164. }
  165.  
  166. CDate::CDate(LONG Days, DateEpoch e)
  167. {
  168.   Set(Days, e);
  169. }
  170.  
  171. CDate::CDate(const CDate& d)
  172. {
  173.   m_lDays = d.m_lDays;
  174.   m_bValid = d.m_bValid;
  175.   m_bInGregCalendar = d.m_bInGregCalendar;
  176. }
  177.  
  178. CDate::CDate(const CTime& ctime)
  179. {
  180.   Set(ctime.GetTime()/86400, EPOCH_CTIME);
  181. }
  182.                                      
  183. CDate::CDate(const COleDateTime& oleTime)
  184. {
  185.   Set(oleTime);
  186. }                     
  187.  
  188. CDate& CDate::Set()
  189. {
  190.   m_lDays = 0;
  191.   m_bValid = FALSE;
  192.   m_bInGregCalendar = FALSE;
  193.   return *this;
  194. }
  195.  
  196. CDate& CDate::Set(LONG Year, WORD Month, WORD Day)
  197. {
  198.   //The following method has been taken from the magazine "Microsoft Systems Journal"
  199.   //I cannot find the copy again, so if anyone recognises the algorithm please let
  200.   //me know so I can credit the author.
  201.  
  202.   if (Month < JANUARY || Month > DECEMBER ||
  203.       Day > DaysInMonth(Month, IsLeap(Year)))
  204.   {
  205.     if (sm_bDoAsserts)
  206.       ASSERT(FALSE);
  207.     Set();
  208.     return *this;
  209.   }
  210.   
  211.   if (((Year > sm_lEndJulianYear) && (Year < sm_lBeginGregYear)) ||
  212.       ((Year == sm_lEndJulianYear) && ((Month > sm_wEndJulianMonth) && (Month < sm_wBeginGregMonth))) ||
  213.       ((Year == sm_lEndJulianYear) && (Month == sm_wEndJulianMonth) && (Day > sm_wEndJulianDay) && (Day < sm_wBeginGregDay)))
  214.   {
  215.     if (sm_bDoAsserts)
  216.       ASSERT(FALSE);
  217.     Set();
  218.     return *this;
  219.   }
  220.  
  221.   SetFebLength(IsLeap(Year));
  222.   m_lDays = (Year-1)*365 + lfloor(Year-1, 4L);
  223.   m_bInGregCalendar = InGregorianCalendar(Year, Month, Day);
  224.   if (m_bInGregCalendar)
  225.     m_lDays += lfloor(Year-1, 400L) - lfloor(Year-1, 100L);
  226.   while (--Month)
  227.     m_lDays += MonthLength[Month];
  228.   //m_lDays += Day - 577736L + 2000000000L - 2*(!m_bInGregCalendar);   //ensure all usable date values are positive
  229.   m_lDays += Day + 1999422264L - 2*(!m_bInGregCalendar);  
  230.  
  231.   ResetFebLength();
  232.  
  233.   m_bValid = TRUE;
  234.  
  235.   return *this;
  236. }
  237.  
  238. CDate& CDate::Set(LONG Year, WORD Month, WORD WeekOfMonth, WORD DayOfWeek)
  239. {
  240.   if (WeekOfMonth < 1 || WeekOfMonth > 5 || DayOfWeek < 1 && DayOfWeek > 7)
  241.   {
  242.     if (sm_bDoAsserts)
  243.       ASSERT(FALSE);
  244.     Set();
  245.     return *this;
  246.   }
  247.  
  248.   if (WeekOfMonth < 5)
  249.   {
  250.     CDate FirstMonth(Year, Month, 1);
  251.     if (!FirstMonth.IsValid())
  252.     {
  253.       if (sm_bDoAsserts)
  254.         ASSERT(FALSE);
  255.       Set();
  256.       return *this;
  257.     }
  258.     WORD dow = FirstMonth.GetDayOfWeek();
  259.     WORD Day = (WORD) (((DayOfWeek - dow + 7) % 7) + (7*(WeekOfMonth-1)) + 1);
  260.     Set(Year, Month, Day);
  261.   }
  262.   else  //5 means the last week of the month
  263.   {
  264.     WORD NewMonth = (WORD) (Month + 1);
  265.     LONG NewYear = Year;
  266.     if (NewMonth > DECEMBER)
  267.     {
  268.       NewMonth = 1;
  269.       ++NewYear;
  270.     }
  271.        
  272.     Set(NewYear, NewMonth, 1, DayOfWeek);
  273.     AddWeek(-1);
  274.   }
  275.  
  276.   return *this;
  277. }
  278.  
  279. CDate& CDate::Set(LONG Days, DateEpoch e)
  280. {
  281.   switch (e)
  282.   {
  283.     case EPOCH_GREG:
  284.     {
  285.       m_lDays = Days + 2000000000L;
  286.       break;
  287.     }
  288.     case EPOCH_JD:    
  289.     {
  290.       //m_lDays = Days - 2299161L + 2000000000L;  //-2299161 coresponds to the GDN of JD Epoch namely 1 January -4712 
  291.       m_lDays = Days + 1997700839L;
  292.       break;
  293.     }
  294.     case EPOCH_MJD:   
  295.     {
  296.       //m_lDays = Days + 100839L + 2000000000L;  //100839 coresponds to the GDN of MJD Epoch namely 17 November 1858 
  297.       m_lDays = Days + 2000100839L;
  298.       break;
  299.     }
  300.     case EPOCH_1900:
  301.     {
  302.       //m_lDays = Days + 115860L + 2000000000L;  //115860 corresponds to the GDN of 1 January 1900
  303.       m_lDays = Days + 2000115860L;
  304.       break;
  305.     }
  306.     case EPOCH_1950:
  307.     {
  308.       //m_lDays = Days + 134122L + 2000000000L;  //134122 corresponds to the GDN of 1 January 1950
  309.       m_lDays = Days + 2000134122L;
  310.       break;
  311.     }
  312.     case EPOCH_CTIME:
  313.     {
  314.       //m_lDays = Days + 141427L + 2000000000L;  //141427 corresponds to the GDN of 1 January 1970
  315.       m_lDays = Days + 2000141427L;
  316.       break;
  317.     }
  318.     case EPOCH_2000:  
  319.     {
  320.       //m_lDays = Days + 152384L + 2000000000L;  //152384 corresponds to the GDN of 1 January 2000
  321.       m_lDays = Days + 2000152384L;
  322.       break;
  323.     }
  324.     default: ASSERT(FALSE); //should not occur
  325.   }
  326.  
  327.   m_bValid = TRUE;
  328.     
  329.   //if (m_lDays - 2000000000L > 2146905911L)  //Largest valid GDN
  330.   if (m_lDays > 4146905911L)  //Largest valid GDN
  331.   {
  332.     if (sm_bDoAsserts)
  333.       ASSERT(FALSE);
  334.     Set();
  335.   }
  336.  
  337.   m_bInGregCalendar = *this > CDate(BeginGregorianYear(), BeginGregorianMonth(), BeginGregorianDay());
  338.  
  339.   return *this;
  340. }
  341.  
  342. CDate& CDate::Set(const SYSTEMTIME& st)
  343. {
  344.   Set(st.wYear, st.wMonth, st.wDay);
  345.   return *this;
  346. }
  347.  
  348. CDate& CDate::Set(const CTime& ctime)
  349. {
  350.   return Set(ctime.GetTime()/86400, EPOCH_CTIME);
  351. }
  352.       
  353. CDate& CDate::Set(const COleDateTime& oleTime)
  354. {
  355.   COleDateTime::DateTimeStatus dts(oleTime.GetStatus());
  356.   CDate rVal;
  357.   if (dts == COleDateTime::DateTimeStatus::valid)
  358.     Set((LONG) oleTime.GetYear(), (WORD) oleTime.GetMonth(), (WORD) oleTime.GetDay());
  359.   else
  360.     Set();
  361.   return *this;
  362. }                     
  363.  
  364. CDate CDate::CurrentDate()
  365. {   
  366.   SYSTEMTIME st;
  367.   ::GetLocalTime(&st);
  368.   return CDate(st);
  369. }
  370.  
  371. WORD CDate::CurrentMonth()
  372. {              
  373.   return CurrentDate().GetMonth();
  374. }
  375.  
  376. WORD CDate::CurrentDay()
  377. {
  378.   return CurrentDate().GetDay();
  379. }
  380.  
  381. LONG CDate::CurrentYear()
  382. {                               
  383.   return CurrentDate().GetYear();
  384. }
  385.  
  386. WORD CDate::CurrentDayOfWeek()
  387. {            
  388.   return CurrentDate().GetDayOfWeek();
  389. }
  390.  
  391. WORD CDate::GetBeginingDayOfWeek()
  392. {
  393.   WORD nDayOfWeek = MONDAY;
  394.   CString sBuf;
  395.   LPTSTR pszBuf = sBuf.GetBuffer(10);
  396.   int nBytes = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IFIRSTDAYOFWEEK, pszBuf, 10);
  397.   ASSERT(nBytes);
  398.   sBuf.ReleaseBuffer();
  399.  
  400.   if (sBuf == _T("0"))
  401.     nDayOfWeek = MONDAY;
  402.   else if (sBuf == _T("1"))
  403.     nDayOfWeek = TUESDAY;
  404.   else if (sBuf == _T("2"))
  405.     nDayOfWeek = WEDNESDAY;
  406.   else if (sBuf == _T("3"))
  407.     nDayOfWeek = THURSDAY;
  408.   else if (sBuf == _T("4"))
  409.     nDayOfWeek = FRIDAY;
  410.   else if (sBuf == _T("5"))
  411.     nDayOfWeek = SATURDAY;
  412.   else if (sBuf == _T("6"))
  413.     nDayOfWeek = SUNDAY;
  414.   else
  415.     ASSERT(FALSE);
  416.  
  417.   return nDayOfWeek;
  418. }
  419.  
  420. BOOL CDate::SetEndJulianCalendar(LONG Year, WORD Month, WORD Day)
  421. {
  422.   //Update the static values in memory first
  423.   sm_wEndJulianDay = Day;
  424.   sm_wEndJulianMonth = Month;
  425.   sm_lEndJulianYear = Year;
  426.  
  427.   //Broadcast a message to all top level windows that we are about to change
  428.   //some internationl settings in the registry
  429.   SendMessage(HWND_BROADCAST, WM_SETTINGCHANGE, NULL, NULL); 
  430.  
  431.   //Settings are stored in the registry under the key HKEY_CURRENT_USER\Control Panel\DTime
  432.   HKEY hcpl;
  433.   BOOL bSuccess = TRUE;
  434.  
  435.   if (RegOpenKeyEx(HKEY_CURRENT_USER,
  436.                    _T("Control Panel"),
  437.                    0,
  438.                    KEY_WRITE,
  439.                    &hcpl) == ERROR_SUCCESS) 
  440.   {
  441.     HKEY happ;
  442.     DWORD dwDisp;
  443.     if (RegCreateKeyEx(hcpl, _T("DTime"), 0, _T(""), REG_OPTION_NON_VOLATILE,
  444.                        KEY_WRITE, NULL, &happ, &dwDisp) == ERROR_SUCCESS) 
  445.     {
  446.       // Set the day part of the end of Julian Calendar
  447.       DWORD dwDay = (DWORD) Day;
  448.       if (RegSetValueEx(happ, _T("JulianEndDay"), 0, REG_DWORD,
  449.                         (BYTE*)&dwDay, sizeof(DWORD)) != ERROR_SUCCESS)
  450.         bSuccess = FALSE;
  451.  
  452.       // Set the month part of the end of Julian Calendar
  453.       DWORD dwMonth = (DWORD) Month;
  454.       if (RegSetValueEx(happ, _T("JulianEndMonth"), 0, REG_DWORD,
  455.                     (BYTE*)&dwMonth, sizeof(DWORD)) != ERROR_SUCCESS)
  456.         bSuccess = FALSE;
  457.  
  458.       // Set the year part of the end of Julian Calendar
  459.       if (RegSetValueEx(happ, _T("JulianEndYear"),  0, REG_DWORD,
  460.                     (BYTE*)&Year, sizeof(LONG)) != ERROR_SUCCESS)
  461.         bSuccess = FALSE;
  462.  
  463.       // Finished with keys
  464.       RegCloseKey(happ);
  465.     }
  466.     else
  467.       bSuccess = FALSE;
  468.  
  469.     RegCloseKey(hcpl);
  470.   }
  471.   else
  472.     bSuccess = FALSE;
  473.  
  474.   return bSuccess;
  475. }
  476.  
  477. BOOL CDate::SetBeginGregorianCalendar(LONG Year, WORD Month, WORD Day)
  478. {
  479.   //Update the static values in memory first
  480.   sm_wBeginGregDay = Day;
  481.   sm_wBeginGregMonth = Month;
  482.   sm_lBeginGregYear = Year;
  483.  
  484.   //Broadcast a message to all top level windows that we are about to change
  485.   //some internationl settings in the registry
  486.   SendMessage(HWND_BROADCAST, WM_SETTINGCHANGE, NULL, NULL); 
  487.  
  488.   //Settings are stored in the registry under the key HKEY_CURRENT_USER\Control Panel\DTime
  489.   HKEY hcpl;
  490.   BOOL bSuccess = TRUE;
  491.  
  492.   if (RegOpenKeyEx(HKEY_CURRENT_USER,
  493.                    _T("Control Panel"),
  494.                    0,
  495.                    KEY_WRITE,
  496.                    &hcpl) == ERROR_SUCCESS) 
  497.   {
  498.     HKEY happ;
  499.     DWORD dwDisp;
  500.     if (RegCreateKeyEx(hcpl, _T("DTime"), 0, _T(""), REG_OPTION_NON_VOLATILE,
  501.                        KEY_WRITE, NULL, &happ, &dwDisp) == ERROR_SUCCESS) 
  502.     {
  503.       // Set the day part of the begin of the Gregorian Calendar
  504.       DWORD dwDay = (DWORD) Day;
  505.       if (RegSetValueEx(happ, _T("GregorianBeginDay"), 0, REG_DWORD,
  506.                         (BYTE*)&dwDay, sizeof(DWORD)) != ERROR_SUCCESS)
  507.         bSuccess = FALSE;
  508.  
  509.       // Set the month part of the begin of the Gregorian Calendar
  510.       DWORD dwMonth = (DWORD) Month;
  511.       if (RegSetValueEx(happ, _T("GregorianBeginMonth"), 0, REG_DWORD,
  512.                     (BYTE*)&dwMonth, sizeof(DWORD)) != ERROR_SUCCESS)
  513.         bSuccess = FALSE;
  514.  
  515.       // Set the year part of the begin of the Gregorian Calendar
  516.       if (RegSetValueEx(happ, _T("GregorianBeginYear"),  0, REG_DWORD,
  517.                     (BYTE*)&Year, sizeof(LONG)) != ERROR_SUCCESS)
  518.         bSuccess = FALSE;
  519.  
  520.       // Finished with keys
  521.       RegCloseKey(happ);
  522.     }
  523.     else
  524.       bSuccess = FALSE;
  525.  
  526.     RegCloseKey(hcpl);
  527.   }
  528.   else
  529.     bSuccess = FALSE;
  530.  
  531.   return bSuccess;
  532. }
  533.  
  534. void CDate::GetEndJulianCalendar(LONG& Year, WORD& Month, WORD& Day)
  535. {
  536.   Year  = sm_lEndJulianYear;
  537.   Month = sm_wEndJulianMonth;
  538.   Day   = sm_wEndJulianDay;
  539. }
  540.  
  541. void CDate::GetBeginGregorianCalendar(LONG& Year, WORD& Month, WORD& Day)
  542. {
  543.   Year  = sm_lBeginGregYear;
  544.   Month = sm_wBeginGregMonth;
  545.   Day   = sm_wBeginGregDay;
  546. }
  547.  
  548. BOOL CDate::InitCalendarSettings()
  549. {
  550.   BOOL bSuccess = TRUE;
  551.  
  552.   // Read the current state from the registry
  553.   // Try opening the registry key:
  554.   // HKEY_CURRENT_USER\Control Panel\DTime
  555.   HKEY hCPL;
  556.   if (RegOpenKeyEx(HKEY_CURRENT_USER,
  557.                    _T("Control Panel"),
  558.                    0,
  559.                    KEY_QUERY_VALUE,
  560.                    &hCPL) == ERROR_SUCCESS) 
  561.   {
  562.     HKEY hApp;
  563.     if (RegOpenKeyEx(hCPL,
  564.                      _T("DTime"),
  565.                      0,
  566.                      KEY_QUERY_VALUE,
  567.                      &hApp) == ERROR_SUCCESS) 
  568.     {
  569.       // Yes we are installed
  570.  
  571.       //the day part of the gregorian begin date
  572.       DWORD dwSize = sizeof(DWORD);
  573.       DWORD dwDay;
  574.       if (RegQueryValueEx(hApp, _T("GregorianBeginDay"), NULL,
  575.                       NULL, (BYTE*)&dwDay, &dwSize) != ERROR_SUCCESS)
  576.         bSuccess = FALSE;
  577.       else
  578.         sm_wBeginGregDay = (WORD) dwDay;
  579.  
  580.       //the month part of the gregorian begin date
  581.       dwSize = sizeof(DWORD);
  582.       DWORD dwMonth;
  583.       if (RegQueryValueEx(hApp, _T("GregorianBeginMonth"), NULL,
  584.                       NULL, (BYTE*)&dwMonth, &dwSize) != ERROR_SUCCESS)
  585.         bSuccess = FALSE;
  586.       else
  587.         sm_wBeginGregMonth = (WORD) dwMonth;
  588.  
  589.       //the year part of the gregorian begin date
  590.       dwSize = sizeof(LONG);
  591.       if (RegQueryValueEx(hApp, _T("GregorianBeginYear"), NULL,
  592.                       NULL, (BYTE*)&sm_lBeginGregYear, &dwSize) != ERROR_SUCCESS)
  593.         bSuccess = FALSE;
  594.  
  595.  
  596.       //the day part of the julian end date
  597.       dwSize = sizeof(DWORD);
  598.       if (RegQueryValueEx(hApp, _T("JulianEndDay"), NULL,
  599.                       NULL, (BYTE*)&dwDay, &dwSize) != ERROR_SUCCESS)
  600.         bSuccess = FALSE;
  601.       else
  602.         sm_wEndJulianDay = (WORD) dwDay;
  603.  
  604.       //the month part of the julian end date
  605.       dwSize = sizeof(DWORD);
  606.       if (RegQueryValueEx(hApp, _T("JulianEndMonth"), NULL,
  607.                       NULL, (BYTE*)&dwMonth, &dwSize) != ERROR_SUCCESS)
  608.         bSuccess = FALSE;
  609.       else
  610.         sm_wEndJulianMonth = (WORD) dwMonth;
  611.  
  612.       //the year part of the julian end date
  613.       dwSize = sizeof(LONG);
  614.       if (RegQueryValueEx(hApp, _T("JulianEndYear"), NULL,
  615.                       NULL, (BYTE*)&sm_lEndJulianYear, &dwSize) != ERROR_SUCCESS)
  616.         bSuccess = FALSE;
  617.  
  618.  
  619.       //Close the DTime Key 
  620.       RegCloseKey(hApp);
  621.     }
  622.     else
  623.       bSuccess = FALSE;
  624.  
  625.     //Close the Control Panel Registry key
  626.     RegCloseKey(hCPL);
  627.   }
  628.   else
  629.     bSuccess = FALSE;
  630.  
  631.   return bSuccess;
  632. }
  633.  
  634. LONG CDate::EndJulianYear()
  635. {
  636.   LONG Year;
  637.   WORD Month;
  638.   WORD Day;
  639.   GetEndJulianCalendar(Year, Month, Day);
  640.   return Year;
  641. }
  642.  
  643. WORD CDate::EndJulianMonth()
  644. {
  645.   LONG Year;
  646.   WORD Month;
  647.   WORD Day;
  648.   GetEndJulianCalendar(Year, Month, Day);
  649.   return Month;
  650. }
  651.  
  652. WORD CDate::EndJulianDay()
  653. {
  654.   LONG Year;
  655.   WORD Month;
  656.   WORD Day;
  657.   GetEndJulianCalendar(Year, Month, Day);
  658.   return Day;
  659. }
  660.  
  661. LONG CDate::BeginGregorianYear()
  662. {
  663.   LONG Year;
  664.   WORD Month;
  665.   WORD Day;
  666.   GetBeginGregorianCalendar(Year, Month, Day);
  667.   return Year;
  668. }
  669.  
  670. WORD CDate::BeginGregorianMonth()
  671. {
  672.   LONG Year;
  673.   WORD Month;
  674.   WORD Day;
  675.   GetBeginGregorianCalendar(Year, Month, Day);
  676.   return Month;
  677. }
  678.  
  679. WORD CDate::BeginGregorianDay()
  680. {
  681.   LONG Year;
  682.   WORD Month;
  683.   WORD Day;
  684.   GetBeginGregorianCalendar(Year, Month, Day);
  685.   return Day;
  686. }
  687.  
  688. BOOL CDate::InGregorianCalendar(LONG Year, WORD Month, WORD Day)
  689. {
  690.   if (Year == BeginGregorianYear())
  691.   {
  692.     if (Month == BeginGregorianMonth())
  693.       return (Day >= BeginGregorianDay());
  694.     else
  695.       return (Month > BeginGregorianMonth());
  696.   }
  697.   else
  698.     return (Year > BeginGregorianYear());
  699. }
  700.  
  701. BOOL CDate::InJulianCalendar(LONG Year, WORD Month, WORD Day)
  702. {
  703.   if (Year == EndJulianYear())
  704.   {
  705.     if (Month == EndJulianMonth())
  706.       return (Day < EndJulianDay());
  707.     else
  708.       return (Month < EndJulianMonth());
  709.   }
  710.   else
  711.     return (Year < EndJulianYear());
  712. }
  713.  
  714.  
  715. #ifdef _DEBUG
  716. BOOL CDate::SetDoConstructorAsserts(BOOL bDoAsserts)
  717. {
  718.   BOOL bOldDoAsserts = sm_bDoAsserts;
  719.   sm_bDoAsserts = bDoAsserts;
  720.   return bOldDoAsserts;
  721. }
  722. #endif
  723.  
  724. CString CDate::GetFullStringDayOfWeek(WORD DayOfWeek)
  725. {
  726.   CString rVal;
  727.   LPTSTR pszBuf = rVal.GetBuffer(100);
  728.   if (DayOfWeek > 0 && DayOfWeek <= 7)
  729.   {
  730.     int nChars;
  731.     switch (DayOfWeek)
  732.     {
  733.       case MONDAY:    nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDAYNAME1, pszBuf, 100); break;
  734.       case TUESDAY:   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDAYNAME2, pszBuf, 100); break;
  735.       case WEDNESDAY: nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDAYNAME3, pszBuf, 100); break;
  736.       case THURSDAY:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDAYNAME4, pszBuf, 100); break;
  737.       case FRIDAY:    nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDAYNAME5, pszBuf, 100); break;
  738.       case SATURDAY:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDAYNAME6, pszBuf, 100); break;
  739.       case SUNDAY:    nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDAYNAME7, pszBuf, 100); break;
  740.       default: ASSERT(FALSE); break;
  741.     }
  742.     ASSERT(nChars);
  743.   }
  744.   else
  745.     ASSERT(FALSE);
  746.   rVal.ReleaseBuffer();
  747.   return rVal;
  748. }
  749.  
  750. CString CDate::GetAbrStringDayOfWeek(WORD DayOfWeek)
  751. {
  752.   CString rVal;
  753.   LPTSTR pszBuf = rVal.GetBuffer(100);
  754.   if (DayOfWeek > 0 && DayOfWeek <= 7)
  755.   {
  756.     int nChars;
  757.     switch (DayOfWeek)
  758.     {
  759.       case MONDAY:    nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1, pszBuf, 100); break;
  760.       case TUESDAY:   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME2, pszBuf, 100); break;
  761.       case WEDNESDAY: nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME3, pszBuf, 100); break;
  762.       case THURSDAY:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME4, pszBuf, 100); break;
  763.       case FRIDAY:    nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME5, pszBuf, 100); break;
  764.       case SATURDAY:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME6, pszBuf, 100); break;
  765.       case SUNDAY:    nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME7, pszBuf, 100); break;
  766.       default: ASSERT(FALSE); break;
  767.     }
  768.     ASSERT(nChars);
  769.   }
  770.   else
  771.     ASSERT(FALSE);
  772.   rVal.ReleaseBuffer();
  773.   return rVal;
  774. }
  775.  
  776. CString CDate::GetFullStringMonth(WORD Month)
  777. {
  778.   CString rVal;
  779.   LPTSTR pszBuf = rVal.GetBuffer(100);
  780.   if (Month > 0 && Month <= 12)
  781.   {
  782.     int nChars;
  783.     switch (Month)
  784.     {
  785.       case JANUARY:   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME1, pszBuf, 100); break;
  786.       case FEBRUARY:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME2, pszBuf, 100); break;
  787.       case MARCH:     nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME3, pszBuf, 100); break;
  788.       case APRIL:     nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME4, pszBuf, 100); break;
  789.       case MAY:       nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME5, pszBuf, 100); break;
  790.       case JUNE:      nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME6, pszBuf, 100); break;
  791.       case JULY:      nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME7, pszBuf, 100); break;
  792.       case AUGUST:    nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME8, pszBuf, 100); break;
  793.       case SEPTEMBER: nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME9, pszBuf, 100); break;
  794.       case OCTOBER:   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME10, pszBuf, 100); break;
  795.       case NOVEMBER:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME11, pszBuf, 100); break;
  796.       case DECEMBER:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME12, pszBuf, 100); break;
  797.       default: ASSERT(FALSE); break;
  798.     }
  799.     ASSERT(nChars);
  800.   }
  801.   else
  802.     ASSERT(FALSE);
  803.   rVal.ReleaseBuffer();
  804.   return rVal;
  805. }
  806.  
  807. CString CDate::GetAbrStringMonth(WORD Month)
  808. {
  809.   CString rVal;
  810.   LPTSTR pszBuf = rVal.GetBuffer(100);
  811.   if (Month > 0 && Month <= 12)
  812.   {
  813.     int nChars;
  814.     switch (Month)
  815.     {
  816.       case JANUARY:   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME1, pszBuf, 100); break;
  817.       case FEBRUARY:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME2, pszBuf, 100); break;
  818.       case MARCH:     nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME3, pszBuf, 100); break;
  819.       case APRIL:     nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME4, pszBuf, 100); break;
  820.       case MAY:       nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME5, pszBuf, 100); break;
  821.       case JUNE:      nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME6, pszBuf, 100); break;
  822.       case JULY:      nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME7, pszBuf, 100); break;
  823.       case AUGUST:    nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME8, pszBuf, 100); break;
  824.       case SEPTEMBER: nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME9, pszBuf, 100); break;
  825.       case OCTOBER:   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME10, pszBuf, 100); break;
  826.       case NOVEMBER:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME11, pszBuf, 100); break;
  827.       case DECEMBER:  nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME12, pszBuf, 100); break;
  828.       default: ASSERT(FALSE); break;
  829.     }
  830.     ASSERT(nChars);
  831.   }
  832.   else
  833.     ASSERT(FALSE);
  834.   rVal.ReleaseBuffer();
  835.   return rVal;
  836. }
  837.  
  838. CDate CDate::FirstCurrentMonth()
  839. {
  840.   CDate c = CDate::CurrentDate();
  841.   return CDate(c.GetYear(), c.GetMonth(), 1); 
  842. }
  843.  
  844. CDate CDate::LastCurrentMonth()
  845. {
  846.   CDate c = CDate::CurrentDate();
  847.   return CDate(c.GetYear(), c.GetMonth(), c.DaysInMonth()); 
  848. }
  849.  
  850. CDate CDate::FirstCurrentYear()
  851. {
  852.   CDate c = CDate::CurrentDate();
  853.   return CDate(c.GetYear(), 1, 1); 
  854. }              
  855.  
  856. CDate CDate::LastCurrentYear()
  857. {
  858.   CDate c = CDate::CurrentDate();
  859.   return CDate(c.GetYear(), 12, CDate::DaysInMonth(12, c.IsLeap())); 
  860. }
  861.  
  862. CDate CDate::JDEpoch()
  863. {
  864.   return CDate(0, EPOCH_JD);
  865. }
  866.  
  867. CDate CDate::MJDEpoch()
  868. {
  869.   return CDate(0, EPOCH_MJD);
  870. }
  871.  
  872. CDate CDate::Epoch1900()
  873. {
  874.   return CDate(0, EPOCH_1900);
  875. }
  876.  
  877. CDate CDate::Epoch1950()
  878. {
  879.   return CDate(0, EPOCH_1950);
  880. }
  881.  
  882. CDate CDate::EpochCTime()
  883. {
  884.   return CDate(0, EPOCH_CTIME);
  885. }
  886.  
  887. CDate CDate::Epoch2000()
  888. {
  889.   return CDate(0, EPOCH_2000);
  890. }
  891.  
  892. CDate CDate::GregorianEpoch()
  893. {
  894.   return CDate(0, EPOCH_GREG);
  895. }                 
  896.  
  897. CDate CDate::NewYearsDay(LONG Year) 
  898. {
  899.   return CDate(Year, JANUARY, 1);
  900. }
  901.  
  902. CDate CDate::ValentinesDay(LONG Year) 
  903. {
  904.   return CDate(Year, FEBRUARY, 14);
  905. }
  906.  
  907. CDate CDate::AshWednesday(LONG Year)
  908. {                                      
  909.   return CDate::EasterSunday(Year) - 39L;    //Ash Wednesday occurs 39 days before Easter Sunday
  910. }
  911.  
  912. CDate CDate::StPatricksDay(LONG Year) 
  913. {
  914.   return CDate(Year, MARCH, 17);
  915. }
  916.  
  917. CDate CDate::GoodFriday(LONG Year)
  918. { 
  919.   return CDate::EasterSunday(Year) - 2L;     //Good Friday occurs 2 days before Easter Sunday
  920. }
  921.  
  922. CDate CDate::EasterSunday(LONG Year)
  923. {
  924.   //The following method has been taken from the book "Astronimical Algorithms" by Jean Meeus
  925.   //which was taken in turn from a book "General Astronomy" by Spencer Jones. It has been 
  926.   //published again in the "Journal of the British Astronomical Association, Vol 88" where
  927.   //it is said that it was devised in 1876 and appeared in Butcher's "Ecclesiastical Calendar"
  928.  
  929.   if (InGregorianCalendar(Year, 4, 1))  //in the Gregorain Calendar, Will possibly give results if Calendar
  930.   {                                     //switches from Julian to Gregorian in March or April because then
  931.     int a = (int) (Year % 19);          //the year may be considered Gregorian or Julian
  932.     int b = (int) (Year / 100);
  933.     int c = (int) (Year % 100);
  934.     int d = b / 4;
  935.     int e = b % 4;
  936.     int f = (b+8) / 25;
  937.     int g = (b - f + 1) / 3;
  938.     int h = (19*a + b - d - g + 15) % 30;
  939.     int i = c / 4;
  940.     int k = c % 4;
  941.     int l = (32 + 2*e + 2*i - h -k) % 7;
  942.     int m = (a + 11*h +22*l) / 451;
  943.     int n = (h + l - 7*m + 114) / 31;
  944.     int p = (h + l - 7*m + 114) % 31;
  945.     return CDate(Year, WORD(n), WORD(p+1));
  946.   }
  947.   else              //in the Julian Calendar
  948.   {                          
  949.     int a = (int) (Year % 4);
  950.     int b = (int) (Year % 7);
  951.     int c = (int) (Year % 19);
  952.     int d = (19*c + 15) % 30;
  953.     int e = (2*a + 4*b - d + 34) % 7;
  954.     int f = (d + e + 114) / 31;
  955.     int g = (d + e + 114) % 31;
  956.     return CDate(Year, (WORD) f, (WORD) (g + 1));
  957.   }  
  958. }
  959.  
  960. CDate CDate::CanadaDay(LONG Year)
  961. {
  962.   return CDate(Year, JULY, 1);
  963. }
  964.  
  965. CDate CDate::IndependenceDay(LONG Year) 
  966. {
  967.   return CDate(Year, JULY, 4);
  968. }
  969.  
  970. CDate CDate::BastilleDay(LONG Year) 
  971. {
  972.   return CDate(Year, JULY, 14);
  973. }
  974.  
  975. CDate CDate::ChristmasDay(LONG Year)  
  976. {
  977.   return CDate(Year, DECEMBER, 25);
  978. }
  979.  
  980. BOOL CDate::IsLeap(LONG Year)
  981. {                
  982.   if (InGregorianCalendar(Year, 1, 1))    //Will give incorrect results if Calendar switches
  983.   {                                       //from Julian to Gregorian in the Year 1600 (if any Country did)
  984.     if ((Year % 100) == 0)                
  985.       return ((Year % 400) == 0) ? TRUE : FALSE;
  986.     else
  987.       return ((Year % 4) == 0) ? TRUE : FALSE;
  988.   }
  989.   else                                        
  990.     return ((Year % 4) == 0) ? TRUE : FALSE;
  991.       
  992. }
  993.  
  994. WORD CDate::DaysInYear(LONG Year)
  995. {
  996.   return IsLeap(Year) ? ((WORD) 366) : ((WORD) 365);
  997. }
  998.  
  999. WORD CDate::DaysInMonth(WORD Month, BOOL IsLeap)
  1000. {
  1001.   SetFebLength(IsLeap);
  1002.   ASSERT(Month >= 1 && Month <= 12);
  1003.   WORD r = MonthLength[Month];
  1004.   ResetFebLength();
  1005.   return r;
  1006. }
  1007.  
  1008. WORD CDate::DaysSinceJan1(WORD Month, WORD Day, BOOL IsLeap)
  1009. {
  1010.   return (WORD) (DaysSinceJan0(Month, Day, IsLeap) - 1);
  1011. }
  1012.  
  1013.  
  1014. WORD CDate::DaysSinceJan0(WORD Month, WORD Day, BOOL IsLeap)
  1015. {            
  1016.   ASSERT(Month >= JANUARY && Month <= DECEMBER);
  1017.   ASSERT(Day <= DaysInMonth(Month, IsLeap) && Day >= 1);
  1018.   int k = IsLeap ? 1 : 2;
  1019.   WORD rVal = (WORD) ((int(275*Month/9)) - (k*int((Month+9)/12)) + Day - 30);
  1020.   return rVal; 
  1021. }
  1022.  
  1023. WORD CDate::DaysSinceJan1() const
  1024. {
  1025.   AssertValid();
  1026.   return (WORD) (*this - CDate(GetYear(), 1, 1));
  1027. }
  1028.  
  1029. WORD CDate::DaysSinceJan0() const
  1030. {
  1031.   AssertValid();
  1032.   return (WORD) (DaysSinceJan1() + 1);
  1033. }
  1034.  
  1035. DateS CDate::GetDate() const
  1036. {
  1037.   //See the comment in CDate::Set(LONG Year, WORD Month, WORD Day)
  1038.   //for references to where the algorithm is taken from
  1039.  
  1040.   AssertValid();
  1041.   BOOL bIsGreg = InGregorianCalendar();
  1042.   BOOL bIsJulian = !bIsGreg;
  1043.   DateS ds;
  1044.   //LONG gdn = m_lDays + 577735L - 2000000000L + 2*bIsJulian;
  1045.   LONG gdn = m_lDays - 1999422265L + 2*bIsJulian;
  1046.   LONG y4 = 1461L;
  1047.   LONG y400 = 146100L - 3*bIsGreg;
  1048.   LONG y100 = 36525L - bIsGreg;
  1049.   BOOL exception=FALSE;
  1050.   ds.lYear = 400*lfloor(gdn, y400);
  1051.   gdn -= y400*lfloor(gdn, y400);       //400 year periods
  1052.   if (gdn > 0L)
  1053.   {
  1054.     ds.lYear += 100*lfloor(gdn, y100);  //100 year periods
  1055.     gdn -= y100*lfloor(gdn, y100);
  1056.     exception = (gdn == 0L && bIsGreg);
  1057.     if (gdn > 0L)
  1058.     {
  1059.       ds.lYear += 4*lfloor(gdn, y4);     //4 year periods
  1060.       gdn -= y4*lfloor(gdn, y4);
  1061.       if (gdn > 0L)
  1062.       {
  1063.         int i=0;
  1064.         while (gdn > 365 && ++i < 4)
  1065.         {
  1066.           ds.lYear++;
  1067.           gdn -= 365L;
  1068.         }
  1069.       }
  1070.     }
  1071.   }
  1072.   if (exception)
  1073.     gdn = 366L; //occurs once every hundred years with Gregorian calendar
  1074.   else
  1075.   {
  1076.     ds.lYear++;
  1077.     gdn++;
  1078.   }
  1079.   SetFebLength(IsLeap(ds.lYear));
  1080.   ds.wMonth = 1;
  1081.   while (ds.wMonth < 13 && gdn > ((LONG) MonthLength[ds.wMonth]))
  1082.     gdn -= MonthLength[ds.wMonth++];
  1083.   if (ds.wMonth == 13)
  1084.   {
  1085.     ds.wMonth = 1;
  1086.     ds.lYear++;
  1087.   }
  1088.   ResetFebLength();
  1089.   ds.wDay = (WORD) gdn;
  1090.   ds.wWday = (WORD) (WeekOfDayModulo(m_lDays, 7) + 1);
  1091.   ds.wYday = DaysSinceJan0(ds.wMonth, ds.wDay, IsLeap(ds.lYear));
  1092.  
  1093.   return ds;
  1094. }
  1095.  
  1096. WORD CDate::GetDay() const
  1097. {
  1098.   AssertValid();
  1099.   return GetDate().wDay;
  1100. }
  1101.  
  1102. WORD CDate::GetMonth() const
  1103. {
  1104.   AssertValid();
  1105.   return GetDate().wMonth;
  1106. }
  1107.  
  1108. LONG CDate::GetYear() const
  1109. {
  1110.   AssertValid();
  1111.   return GetDate().lYear;
  1112. }
  1113.  
  1114. LONG CDate::GetCEBCEYear(BOOL& IsCE) const
  1115. {
  1116.   AssertValid();
  1117.   LONG Year = GetDate().lYear;
  1118.  
  1119.   if (Year > 0)
  1120.   {
  1121.     IsCE = TRUE;
  1122.     return Year;
  1123.   }
  1124.   else
  1125.   {
  1126.     IsCE = FALSE;
  1127.     return labs(GetYear() - 1);
  1128.   }
  1129. }
  1130.  
  1131. WORD CDate::Get2DigitYear() const
  1132. {
  1133.   AssertValid();
  1134.   LONG Year = labs(GetYear());
  1135.   return (WORD) (Year - ((Year/100)*100));
  1136. }
  1137.  
  1138.  
  1139. WORD CDate::GetWeekOfYear() const
  1140. {               
  1141.   AssertValid(); 
  1142.   CDate FirstOfYear(GetYear(), JANUARY, 1, GetBeginingDayOfWeek());
  1143.   LONG diff = *this - FirstOfYear;
  1144.   if (diff < 0)
  1145.     return 0;
  1146.   else
  1147.     return (WORD) (diff/7 + 1);
  1148. }
  1149.  
  1150.  
  1151. WORD CDate::GetWeekOfMonth() const
  1152. {                  
  1153.   AssertValid();
  1154.   CDate FirstOfMonth(GetYear(), GetMonth(), 1, GetBeginingDayOfWeek());
  1155.   LONG diff = *this - FirstOfMonth;
  1156.   if (diff < 0)
  1157.     return 0;
  1158.   else
  1159.     return (WORD) (diff/7 + 1);
  1160. }
  1161.  
  1162. LONG CDate::Since1900Epoch() const
  1163. {
  1164.   AssertValid();
  1165.   return *this - CDate(1900, 1, 1);
  1166. }
  1167.  
  1168. LONG CDate::Since1950Epoch() const
  1169. {
  1170.   AssertValid();
  1171.   return *this - CDate(1950, 1, 1);
  1172. }
  1173.  
  1174. LONG CDate::SinceCTimeEpoch() const
  1175. {
  1176.   AssertValid();  
  1177.   return *this - CDate(1970, 1, 1);
  1178. }
  1179.  
  1180. LONG CDate::Since2000Epoch() const
  1181. {
  1182.   AssertValid();
  1183.   return *this - CDate(2000, 1, 1);
  1184. }
  1185.  
  1186. LONG CDate::JD() const
  1187. {
  1188.   AssertValid();
  1189.   return *this - JDEpoch();
  1190. }
  1191.  
  1192. LONG CDate::GDN() const
  1193. {
  1194.   AssertValid();
  1195.   return m_lDays - 2000000000L;
  1196. }
  1197.  
  1198. LONG CDate::GetValue() const
  1199. {
  1200.   AssertValid();
  1201.   return m_lDays;
  1202. }
  1203.  
  1204. BOOL CDate::IsLeap() const
  1205. {
  1206.   AssertValid();
  1207.   return IsLeap(GetYear());
  1208. }
  1209.  
  1210. WORD CDate::DaysInYear() const
  1211. { 
  1212.   AssertValid();
  1213.   return DaysInYear(GetYear());
  1214. }
  1215.  
  1216. WORD CDate::DaysInMonth() const
  1217. {
  1218.   AssertValid();
  1219.   return DaysInMonth(GetMonth(), IsLeap());
  1220. }
  1221.  
  1222. void CDate::AddYear(int Years)
  1223. {
  1224.   AssertValid();
  1225.   LONG Months = Years*12;
  1226.   if (Months >= INT_MIN && Months <= INT_MAX)
  1227.     AddMonth((int) Months);
  1228.   else
  1229.   {
  1230.     ASSERT(FALSE);
  1231.     Set();
  1232.   }
  1233. }
  1234.  
  1235. void CDate::AddMonth(int Months)
  1236. {
  1237.   AssertValid();
  1238.   LONG NewMonth = (LONG) GetMonth();
  1239.   LONG NewYear = GetYear();
  1240.   NewMonth += Months;
  1241.   if ((NewMonth > DECEMBER) || (NewMonth < JANUARY))
  1242.   {
  1243.     NewYear += NewMonth / 12;
  1244.     NewMonth = NewMonth % 12;
  1245.   }
  1246.   if (NewMonth < JANUARY)
  1247.   {
  1248.     --NewYear;
  1249.     NewMonth += 12;
  1250.   }
  1251.  
  1252.   WORD Day = GetDay();
  1253.  
  1254.   WORD MaxDays = DaysInMonth((WORD) NewMonth, IsLeap(NewYear));
  1255.   if (Day > MaxDays)
  1256.     Day = MaxDays;
  1257.   Set(NewYear, (WORD) NewMonth, Day);
  1258. }
  1259.  
  1260. void CDate::AddWeek(int Weeks)
  1261. {
  1262.   AssertValid();
  1263.   *this += 7L*((LONG)Weeks);
  1264. }
  1265.  
  1266. WORD CDate::GetDayOfWeek() const
  1267. {
  1268.   AssertValid();
  1269.   return (WORD) (WeekOfDayModulo(m_lDays, 7) + 1);
  1270. }
  1271.  
  1272. CString CDate::GetStringCEBCEYear() const
  1273. {
  1274.   AssertValid();
  1275.   BOOL bIsCEYear;
  1276.   LONG lCEYear = GetCEBCEYear(bIsCEYear);
  1277.   CString sYear;                    
  1278.   sYear.Format(_T("%ld"), lCEYear);
  1279.   CString rVal;
  1280.   if (bIsCEYear)
  1281.     AfxFormatString1(rVal, IDS_CEYEAR, sYear);
  1282.   else
  1283.     AfxFormatString1(rVal, IDS_BCEYEAR, sYear);
  1284.   return rVal;
  1285. }
  1286.  
  1287. CString CDate::GetFullStringDayOfWeek() const
  1288. {
  1289.   AssertValid();
  1290.   return GetFullStringDayOfWeek(GetDayOfWeek());
  1291. }
  1292.  
  1293. CString CDate::GetAbrStringDayOfWeek() const
  1294. {
  1295.   AssertValid();
  1296.   return GetAbrStringDayOfWeek(GetDayOfWeek());
  1297. }
  1298.  
  1299. CString CDate::GetFullStringMonth() const
  1300. {
  1301.   AssertValid();
  1302.   return GetFullStringMonth(GetMonth());
  1303. }
  1304.  
  1305. CString CDate::GetAbrStringMonth() const
  1306. {
  1307.   AssertValid();
  1308.   return GetAbrStringMonth(GetMonth());
  1309. }
  1310.  
  1311. SYSTEMTIME CDate::GetSYSTEMTIME() const
  1312. {
  1313.   AssertValid();
  1314.   SYSTEMTIME s;
  1315.   s.wYear = 0;
  1316.   s.wMonth = 0;
  1317.   s.wDayOfWeek = 0;
  1318.   s.wDay = 0;
  1319.   s.wHour = 0;
  1320.   s.wMinute = 0;
  1321.   s.wSecond = 0;
  1322.   s.wMilliseconds = 0;
  1323.  
  1324.   DateS ds = GetDate();
  1325.  
  1326.   //handle range errors
  1327.   if ((ds.lYear < 0) || (ds.lYear > USHRT_MAX))
  1328.   {
  1329.     ASSERT(FALSE);
  1330.     s.wYear = 0;
  1331.     return s;
  1332.   }
  1333.   
  1334.   s.wYear = (WORD) ds.lYear;
  1335.   s.wMonth = ds.wMonth;
  1336.   s.wDayOfWeek = (WORD) (ds.wWday - 1);  //SYSTEMTIME uses 0 based indices
  1337.   s.wDay = ds.wDay;
  1338.  
  1339.   return s;
  1340. }                
  1341.                           
  1342. tm CDate::GetTM() const
  1343. {
  1344.   AssertValid();
  1345.   tm rVal;
  1346.   
  1347.   rVal.tm_sec   = 0;
  1348.   rVal.tm_min   = 0;
  1349.   rVal.tm_hour  = 0;
  1350.   rVal.tm_mday  = 0;
  1351.   rVal.tm_mon   = 0;
  1352.   rVal.tm_year  = 0;
  1353.   rVal.tm_wday  = 0;
  1354.   rVal.tm_yday  = 0;
  1355.   rVal.tm_isdst = 0;
  1356.  
  1357.   DateS ds = GetDate(); 
  1358.      
  1359.   long MinYear = 1900L + LONG_MIN;
  1360.   long MaxYear = LONG_MAX;
  1361.  
  1362.   //handle range errors
  1363.   if ((ds.lYear < MinYear) || (ds.lYear > MaxYear))
  1364.   {
  1365.     ASSERT(FALSE);
  1366.     return rVal;
  1367.   }
  1368.   
  1369.   rVal.tm_year = (int) (ds.lYear - 1900L);
  1370.   rVal.tm_mon = ds.wMonth - 1;  //tm struct uses 0 based indices
  1371.   rVal.tm_wday = ds.wWday - 1;  //tm struct uses 0 based indices
  1372.   rVal.tm_mday = ds.wDay; 
  1373.   rVal.tm_wday = ds.wYday - 1; //Returns days since Jan 1
  1374.               
  1375.   return rVal;
  1376. }
  1377.  
  1378. BOOL CDate::IsValid() const
  1379. {
  1380.   return m_bValid;
  1381. }
  1382.  
  1383. LONG CDate::Collate() const
  1384. {
  1385.   AssertValid();
  1386.   DateS s;
  1387.   s = GetDate();
  1388.   return (s.lYear*10000) + (s.wMonth*100) + s.wDay;
  1389. }
  1390.  
  1391. BOOL CDate::InGregorianCalendar() const
  1392. {
  1393.   AssertValid();
  1394.   return m_bInGregCalendar;
  1395. }
  1396.  
  1397. BOOL CDate::InJulianCalendar() const
  1398. {
  1399.   AssertValid();
  1400.   return !m_bInGregCalendar;
  1401. }
  1402.  
  1403. CDate CDate::FirstThisMonth() const
  1404. {
  1405.   AssertValid();
  1406.   DateS s=GetDate();
  1407.   return CDate(s.lYear, s.wMonth, 1);  
  1408. }
  1409.  
  1410. CDate CDate::LastThisMonth() const
  1411. {
  1412.   AssertValid();
  1413.   DateS s = GetDate();
  1414.   return CDate(s.lYear, s.wMonth, DaysInMonth(s.wMonth, IsLeap(s.lYear)));  
  1415. }
  1416.  
  1417. CDate CDate::FirstThisYear() const
  1418. {
  1419.   AssertValid();
  1420.   DateS s = GetDate();
  1421.   CDate d(s.lYear, JANUARY, 1);
  1422.   return d;  
  1423. }
  1424.  
  1425. CDate CDate::LastThisYear() const
  1426. {
  1427.   AssertValid();
  1428.   DateS s = GetDate();
  1429.   CDate d(s.lYear, DECEMBER, 1);
  1430.   return d;  
  1431. }
  1432.  
  1433. CDate& CDate::operator=(const CDate& d)
  1434. {
  1435.   m_lDays = d.m_lDays;
  1436.   m_bInGregCalendar = d.m_bInGregCalendar;
  1437.   m_bValid = d.m_bValid;
  1438.   return *this;
  1439. }
  1440.  
  1441. CDate CDate::operator+(LONG Days) const
  1442. {
  1443.   AssertValid();
  1444.   return CDate(GDN() + Days, EPOCH_GREG);
  1445. }
  1446.  
  1447. LONG CDate::operator-(const CDate& d) const
  1448. {
  1449.   AssertValid();
  1450.   return m_lDays - d.m_lDays;
  1451. }
  1452.  
  1453. CDate CDate::operator-(LONG Days) const
  1454. {
  1455.   AssertValid();
  1456.   return CDate(GDN() - Days, EPOCH_GREG);
  1457. }
  1458.  
  1459. CDate& CDate::operator+=(LONG Days)
  1460. {
  1461.   AssertValid();
  1462.   m_lDays += Days;
  1463.   return *this;
  1464. }
  1465.  
  1466. CDate& CDate::operator-=(LONG Days)
  1467. {
  1468.   AssertValid();
  1469.   m_lDays -= Days;
  1470.   return *this;
  1471. }
  1472.  
  1473. CDate& CDate::operator++()
  1474. {
  1475.   AssertValid();
  1476.   m_lDays++;
  1477.   return *this;
  1478. }
  1479.  
  1480. CDate& CDate::operator--()
  1481. {
  1482.   AssertValid();
  1483.   m_lDays--;
  1484.   return *this;
  1485. }
  1486.  
  1487. BOOL CDate::operator==(const CDate& d) const
  1488. {
  1489.   AssertValid();
  1490.   return m_lDays == d.m_lDays;
  1491. }
  1492.  
  1493. BOOL CDate::operator>(const CDate& d) const
  1494. {
  1495.   AssertValid();
  1496.   return m_lDays > d.m_lDays;
  1497. }
  1498.  
  1499. BOOL CDate::operator>=(const CDate& d) const
  1500. {
  1501.   AssertValid();
  1502.   return m_lDays >= d.m_lDays;
  1503. }
  1504.  
  1505. BOOL CDate::operator<(const CDate& d) const
  1506. {
  1507.   AssertValid();
  1508.   return m_lDays < d.m_lDays;
  1509. }
  1510.  
  1511. BOOL CDate::operator<=(const CDate& d) const
  1512. {
  1513.   AssertValid();
  1514.   return m_lDays <= d.m_lDays;
  1515. }
  1516.  
  1517. BOOL CDate::operator!=(const CDate& d) const
  1518. {
  1519.   AssertValid();
  1520.   return m_lDays != d.m_lDays;
  1521. }
  1522.  
  1523. #ifdef _DEBUG
  1524. void CDate::AssertValid() const
  1525. {
  1526.   CObject::AssertValid();
  1527.   ASSERT(IsValid());
  1528. }
  1529. #endif
  1530.  
  1531. #ifdef _DEBUG
  1532. void CDate::Dump(CDumpContext& dc) const
  1533. {
  1534.   CObject::Dump(dc);
  1535.   if (IsValid())
  1536.     dc << Format() << _T("\n");
  1537.   else
  1538.     dc << _T("Invalid state\n");
  1539. }
  1540. #endif
  1541.  
  1542. /*    //The Following Format parameters are supported
  1543.  
  1544. %a    Abbreviated weekday name
  1545. %A    Full weekday name
  1546. %b    Abbreviated month name
  1547. %B    Full month name
  1548. %d    Day of month as decimal number (01 - 31)
  1549. %j    Day of year as decimal number (001 - 366)
  1550. %m    Month as decimal number (01 - 12)
  1551. %U    Week of year as decimal number
  1552. %w    Weekday as decimal number (1 - 7; Sunday is 1)
  1553. %x    Short date representation, appropriate to current locale
  1554. %y    Year without century, as decimal number (00 - 99)
  1555. %Y    Year with century, as decimal number
  1556. %c    Year displayed using C.E.(Current Epoch) / B.C.E (Before Current Epoch) convention e.g. -1023 = 1022 BCE
  1557. %#x   Long date representation, appropriate to current locale
  1558. %#d, %#j, %#m, %#U, %#y Remove leading zeros (if any)
  1559. */
  1560. CString CDate::Format(const CString& sFormat) const
  1561. { 
  1562.   CString rVal;
  1563.   if (IsValid())
  1564.   {
  1565.     CString sBuffer;
  1566.     int sFmtLength = sFormat.GetLength();
  1567.  
  1568.     for (int i=0; i<sFmtLength; i++)
  1569.     {
  1570.       TCHAR c = sFormat.GetAt(i);
  1571.       if (c == _T('%'))
  1572.       {
  1573.         ++i;
  1574.         if (i < sFmtLength)
  1575.         {
  1576.           c = sFormat.GetAt(i);
  1577.           switch (c)
  1578.           {
  1579.             case _T('a'):
  1580.             {
  1581.               rVal += GetAbrStringDayOfWeek();
  1582.               break;
  1583.             }
  1584.             case _T('A'):
  1585.             {
  1586.               rVal += GetFullStringDayOfWeek();
  1587.               break;
  1588.             }
  1589.             case _T('b'):
  1590.             {
  1591.               rVal += GetAbrStringMonth();
  1592.               break;
  1593.             }
  1594.             case _T('c'):
  1595.             {
  1596.               rVal += GetStringCEBCEYear();
  1597.               break;
  1598.             }
  1599.             case _T('B'):
  1600.             {
  1601.               rVal += GetFullStringMonth();
  1602.               break;
  1603.             }
  1604.             case _T('d'):
  1605.             {
  1606.               sBuffer.Format(_T("%.02d"), GetDay());
  1607.               rVal += sBuffer;
  1608.               break;
  1609.             }
  1610.             case _T('j'):
  1611.             {
  1612.               sBuffer.Format(_T("%.03d"), DaysSinceJan0());
  1613.               rVal += sBuffer;
  1614.               break;
  1615.             }
  1616.             case _T('m'):
  1617.             {
  1618.               sBuffer.Format(_T("%.02d"), GetMonth());
  1619.               rVal += sBuffer;
  1620.               break;
  1621.             }
  1622.             case _T('U'):
  1623.             {
  1624.               sBuffer.Format(_T("%.02d"), GetWeekOfYear());
  1625.               rVal += sBuffer;
  1626.               break;
  1627.             }
  1628.             case _T('w'):
  1629.             {
  1630.               sBuffer.Format(_T("%d"), GetDayOfWeek());
  1631.               rVal += sBuffer;
  1632.               break;
  1633.             }                                   
  1634.             case _T('x'):
  1635.             {
  1636.               sBuffer.Empty();
  1637.               SYSTEMTIME st = GetSYSTEMTIME();
  1638.               int Res = ::GetDateFormat(LOCALE_USER_DEFAULT,
  1639.                                       DATE_SHORTDATE,
  1640.                                       &st,
  1641.                                       NULL,
  1642.                                       sBuffer.GetBufferSetLength(100),
  1643.                                       100); 
  1644.               if (Res == 0)
  1645.                 TRACE1("GetDateFormat() Failed in CDate::Format(), GetLastError() returned %ul\n", ::GetLastError());
  1646.               sBuffer.ReleaseBuffer();
  1647.               rVal += sBuffer;
  1648.               break;
  1649.             }                 
  1650.             case _T('y'):
  1651.             {
  1652.               LONG Year = GetYear();
  1653.               sBuffer.Format(_T("%.02d"), Get2DigitYear());
  1654.               rVal += sBuffer;
  1655.               break;
  1656.             }
  1657.             case _T('Y'):
  1658.             {
  1659.               sBuffer.Format(_T("%ld"), GetYear());
  1660.               rVal += sBuffer;
  1661.               break;
  1662.             }
  1663.             case _T('#'):
  1664.             {
  1665.               if (i < sFmtLength)
  1666.               {
  1667.                 ++i;
  1668.                 c = sFormat.GetAt(i);
  1669.                 switch (c)
  1670.                 {
  1671.                   case _T('d'):
  1672.                   {
  1673.                     sBuffer.Format(_T("%d"), GetDay());
  1674.                     rVal += sBuffer;
  1675.                     break;
  1676.                   }
  1677.                   case _T('j'):
  1678.                   {
  1679.                     sBuffer.Format(_T("%d"), DaysSinceJan0());
  1680.                     rVal += sBuffer;
  1681.                     break;
  1682.                   }
  1683.                   case _T('m'):
  1684.                   {
  1685.                     sBuffer.Format(_T("%d"), GetMonth());
  1686.                     rVal += sBuffer;
  1687.                     break;
  1688.                   }
  1689.                   case _T('U'):
  1690.                   {
  1691.                     sBuffer.Format(_T("%d"), GetWeekOfYear());
  1692.                     rVal += sBuffer;
  1693.                     break;
  1694.                   }                                    
  1695.                   case _T('x'):
  1696.                   {
  1697.                     sBuffer.Empty();
  1698.                     SYSTEMTIME st = GetSYSTEMTIME();
  1699.                     int Res = ::GetDateFormat(LOCALE_USER_DEFAULT,
  1700.                                             DATE_LONGDATE,
  1701.                                             &st,
  1702.                                             NULL,
  1703.                                             sBuffer.GetBufferSetLength(100),
  1704.                                             100); 
  1705.                     if (Res == 0)
  1706.                       TRACE1("GetDateFormat() Failed in CDate::Format(), GetLastError() returned %ul\n", ::GetLastError());
  1707.  
  1708.                     sBuffer.ReleaseBuffer();
  1709.                     rVal += sBuffer;
  1710.                     break;
  1711.                   }               
  1712.                   case _T('y'):
  1713.                   {
  1714.                     LONG Year = GetYear();
  1715.                     sBuffer.Format(_T("%d"), Get2DigitYear());
  1716.                     rVal += sBuffer;
  1717.                     break;
  1718.                   }
  1719.                   default:
  1720.                   {
  1721.                     rVal += c;
  1722.                     break;
  1723.                   }
  1724.                 }
  1725.               }
  1726.               break;
  1727.             }
  1728.             default:
  1729.             {
  1730.               rVal += c;
  1731.               break;
  1732.             }
  1733.           }
  1734.         }
  1735.       }
  1736.       else
  1737.       {
  1738.         rVal += c;
  1739.       }
  1740.     }
  1741.   }
  1742.  
  1743.   return rVal;
  1744. }
  1745.  
  1746. //Format according to the short date format as specified by the control panel
  1747. CString CDate::Format() const
  1748. {
  1749.   return Format(sm_sDefaultFormat);
  1750. }
  1751.  
  1752. void CDate::GetDefaultFormat()
  1753. {
  1754.   CString sBuf;
  1755.  
  1756.   // Is there to be a leading 0 on the day?
  1757.   BOOL bDayLZ = FALSE;
  1758.   LPTSTR pszBuf = sBuf.GetBuffer(10);
  1759.   int nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDAYLZERO, pszBuf, 10);
  1760.   ASSERT(nChars);
  1761.   sBuf.ReleaseBuffer();
  1762.   if (sBuf == _T("0"))  //No leading zeros for days
  1763.     bDayLZ = FALSE;
  1764.   else if (sBuf == _T("1"))  //Leading zeros for days
  1765.     bDayLZ = TRUE;
  1766.   else
  1767.     ASSERT(FALSE);
  1768.  
  1769.   // Is there to be a leading 0 on the month?
  1770.   BOOL bMoLZ = TRUE;
  1771.   pszBuf = sBuf.GetBuffer(10);
  1772.   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IMONLZERO, pszBuf, 10);
  1773.   ASSERT(nChars);
  1774.   sBuf.ReleaseBuffer();
  1775.   if (sBuf == _T("0"))  //No leading zeros for months
  1776.     bMoLZ = FALSE;
  1777.   else if (sBuf == _T("1"))  //Leading zeros for months
  1778.     bMoLZ = TRUE;
  1779.   else
  1780.     ASSERT(FALSE);
  1781.  
  1782.  
  1783.   // Find if only 2 digits are to be displayed for the year
  1784.   BOOL b2DigitYear = FALSE;
  1785.  
  1786.   //Because DTime can allow years to be much larger than 4 digits in size,
  1787.   //DTime always explicitly shows all the year digits, instead of looking
  1788.   //at the LOCALE_ICENTURY LCTYPE, but commented out below is the code
  1789.   //that would be required for those interested
  1790.  
  1791.   /*
  1792.   pszBuf = sBuf.GetBuffer(10);
  1793.   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ICENTURY, pszBuf, 10);
  1794.   ASSERT(nChars);
  1795.   sBuf.ReleaseBuffer();
  1796.   if (sBuf == _T("0"))  //Abbreviated 2-digit century
  1797.     b2DigitYear = TRUE;
  1798.   else if (sBuf == _T("1"))  //Full century
  1799.     b2DigitYear = FALSE;
  1800.   else
  1801.     ASSERT(FALSE);
  1802.   */
  1803.   
  1804.  
  1805.   // Get the date separator character
  1806.   CString sSep(_T("/"));
  1807.   pszBuf = sSep.GetBuffer(10);
  1808.   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDATE, pszBuf, 10);
  1809.   ASSERT(nChars);
  1810.   sSep.ReleaseBuffer();
  1811.  
  1812.  
  1813.   //Retrieve the short date formatting string
  1814.   pszBuf = sBuf.GetBuffer(10);
  1815.   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDATE, pszBuf, 10);
  1816.   ASSERT(nChars);
  1817.   sBuf.ReleaseBuffer();
  1818.  
  1819.  
  1820.   //Format according to the short date formatting string     //THESE CODES NEED TO BE CHECKED
  1821.   if (sBuf == _T("0"))  //MDY format
  1822.   {
  1823.     if (b2DigitYear)
  1824.       sm_sDefaultFormat.Format(_T("%s%s%s%s%%y"), bMoLZ ? _T("%m") : _T("%#m"), sSep, bDayLZ ? _T("%d") : _T("%#d"), sSep);
  1825.     else
  1826.       sm_sDefaultFormat.Format(_T("%s%s%s%s%%Y"), bMoLZ ? _T("%m") : _T("%#m"), sSep, bDayLZ ? _T("%d") : _T("%#d"), sSep);
  1827.   }
  1828.   else if (sBuf == _T("1"))  //DMY format
  1829.   {
  1830.     if (b2DigitYear)
  1831.       sm_sDefaultFormat.Format(_T("%s%s%s%s%%y"), bDayLZ ? _T("%d") : _T("%#d"), sSep, bMoLZ ? _T("%m") : _T("%#m"), sSep);
  1832.     else
  1833.       sm_sDefaultFormat.Format(_T("%s%s%s%s%%Y"), bDayLZ ? _T("%d") : _T("%#d"), sSep, bMoLZ ? _T("%m") : _T("%#m"), sSep);
  1834.   }
  1835.   else 
  1836.   {
  1837.     if (sBuf != _T("2"))  //No Recognized format available
  1838.       ASSERT(FALSE);
  1839.  
  1840.     //YMD Format
  1841.     if (b2DigitYear)
  1842.       sm_sDefaultFormat.Format(_T("%%y%s%s%s%s"), sSep, bMoLZ ? _T("%m") : _T("%#m"), sSep, bDayLZ ? _T("%d") : _T("%#d"));
  1843.     else
  1844.       sm_sDefaultFormat.Format(_T("%%Y%s%s%s%s"), sSep, bMoLZ ? _T("%m") : _T("%#m"), sSep, bDayLZ ? _T("%d") : _T("%#d"));
  1845.   }
  1846. }
  1847.  
  1848.  
  1849. void CDate::Serialize(CArchive& ar)
  1850. {
  1851.   CObject::Serialize(ar);
  1852.  
  1853.   if (ar.IsStoring())
  1854.   {
  1855.     ar << m_lDays;
  1856.     ar << (WORD) m_bInGregCalendar;
  1857.     ar << m_bValid;
  1858.   }
  1859.   else
  1860.   {
  1861.     ar >> m_lDays;
  1862.     ar >> (WORD&) m_bInGregCalendar;
  1863.     ar >> m_bValid;
  1864.   }
  1865. }
  1866.  
  1867. ostream& operator<<(ostream& os, const CDate& date)
  1868. {
  1869.   return os << date.Format();
  1870. }
  1871.  
  1872. CArchive& operator<<(CArchive& ar, CDate& date)
  1873. {
  1874.   ASSERT(ar.IsStoring());
  1875.   date.Serialize(ar);
  1876.   return ar;
  1877. }
  1878.  
  1879. CArchive& operator>>(CArchive& ar, CDate& date)
  1880. {
  1881.   ASSERT(!ar.IsStoring());
  1882.   date.Serialize(ar);
  1883.   return ar;
  1884. }
  1885.  
  1886.  
  1887.  
  1888.  
  1889.  
  1890.  
  1891.  
  1892. //CLTimeSpan Implementation
  1893.  
  1894.  
  1895. CLTimeSpan::CLTimeSpan()
  1896. {
  1897.   Set();
  1898. }
  1899.  
  1900. CLTimeSpan::CLTimeSpan(LONG Day, WORD Hour, WORD Minute, 
  1901.                        WORD Second)
  1902. {
  1903.   Set(Day, Hour, Minute, Second);
  1904. }
  1905.  
  1906. CLTimeSpan::CLTimeSpan(const CLTimeSpan& lts)
  1907. {
  1908.   m_nSeconds = lts.m_nSeconds;
  1909.   m_bValid   = lts.m_bValid;
  1910. }
  1911.  
  1912. CLTimeSpan::CLTimeSpan(const CTimeSpan& ts)
  1913. {
  1914.   Set(ts);
  1915. }
  1916.  
  1917. CLTimeSpan::CLTimeSpan(const CLTimeOfDay& tod)
  1918. {
  1919.   Set(tod);
  1920. }
  1921.       
  1922. CLTimeSpan::CLTimeSpan(const COleDateTimeSpan& oleTimeSpan)
  1923. {
  1924.   Set(oleTimeSpan);
  1925. }                     
  1926.  
  1927. CLTimeSpan::CLTimeSpan(const __int64& Seconds)
  1928. {
  1929.   Set(Seconds);
  1930. }
  1931.  
  1932. CLTimeSpan& CLTimeSpan::Set()
  1933. {                          
  1934.   m_nSeconds = 0;
  1935.   m_bValid = FALSE;
  1936.   return *this;
  1937. }
  1938.  
  1939. CLTimeSpan& CLTimeSpan::Set(LONG Day, WORD Hour, WORD Minute, 
  1940.                             WORD Second)
  1941. { 
  1942.   if (Day >= 0)
  1943.     m_nSeconds = __int64(Day)*86400L + __int64(Hour)*3600L + __int64(Minute)*60L + Second;
  1944.   else
  1945.     m_nSeconds = __int64(Day)*86400L - __int64(Hour)*3600L - __int64(Minute)*60L - Second;
  1946.   m_bValid = TRUE;
  1947.   return *this;
  1948. }                            
  1949.  
  1950. CLTimeSpan& CLTimeSpan::Set(const CTimeSpan& ts)
  1951. {
  1952.   m_nSeconds = ts.GetTotalSeconds();
  1953.   m_bValid   = TRUE;
  1954.   return *this;
  1955. }
  1956.  
  1957. CLTimeSpan& CLTimeSpan::Set(const CLTimeOfDay& tod)
  1958. {
  1959.   Set(0, tod.GetHour(), tod.GetMinute(), tod.GetSecond());
  1960.   return *this;
  1961. }
  1962.       
  1963. CLTimeSpan& CLTimeSpan::Set(const COleDateTimeSpan& oleTimeSpan)
  1964. {
  1965.   COleDateTimeSpan::DateTimeSpanStatus dtss(oleTimeSpan.GetStatus());
  1966.   CLTimeSpan rVal;
  1967.   if (dtss == COleDateTimeSpan::DateTimeSpanStatus::valid)
  1968.     Set(oleTimeSpan.GetTotalSeconds());
  1969.   else
  1970.     Set();
  1971.   return *this;
  1972. }                     
  1973.  
  1974. CLTimeSpan& CLTimeSpan::Set(const __int64& Seconds)
  1975. { 
  1976.   m_nSeconds = Seconds;
  1977.   m_bValid = TRUE;
  1978.   return *this;
  1979. }
  1980.  
  1981. CLTimeSpan CLTimeSpan::OneCivilYear()
  1982. {
  1983.   return CLTimeSpan(365, 6, 0, 0);
  1984. }
  1985.  
  1986. CLTimeSpan CLTimeSpan::OneDay()
  1987. {
  1988.   return CLTimeSpan(1, 0, 0, 0);
  1989. }
  1990.  
  1991. CLTimeSpan CLTimeSpan::OneHour()
  1992. {
  1993.   return CLTimeSpan(0, 1, 0, 0);
  1994. }
  1995.  
  1996. CLTimeSpan CLTimeSpan::OneMinute()
  1997. {
  1998.   return CLTimeSpan(0, 0, 1, 0);
  1999. }
  2000.  
  2001. CLTimeSpan CLTimeSpan::OneSecond()
  2002. {
  2003.   return CLTimeSpan(0, 0, 0, 1);
  2004. }
  2005.  
  2006. #ifdef _DEBUG
  2007. BOOL CLTimeSpan::SetDoConstructorAsserts(BOOL bDoAsserts)
  2008. {
  2009.   BOOL bOldDoAsserts = sm_bDoAsserts;
  2010.   sm_bDoAsserts = bDoAsserts;
  2011.   return bOldDoAsserts;
  2012. }
  2013. #endif                     
  2014.  
  2015. LONG CLTimeSpan::GetTotalDays() const
  2016. {
  2017.   AssertValid();
  2018.   return (LONG) (m_nSeconds/86400);
  2019. }
  2020.  
  2021. WORD CLTimeSpan::GetHours() const
  2022. {
  2023.   AssertValid();
  2024.  
  2025.   if (IsPositiveSpan())
  2026.     return (WORD) ((m_nSeconds - 86400*__int64(GetTotalDays()))/3600L);
  2027.   else
  2028.   {
  2029.     CLTimeSpan n(*this);
  2030.     n.Negate();
  2031.     return n.GetHours();
  2032.   }  
  2033. }
  2034.  
  2035. WORD CLTimeSpan::GetMinutes() const
  2036. {
  2037.   AssertValid();
  2038.  
  2039.   if (IsPositiveSpan())
  2040.     return (WORD) ((m_nSeconds - 86400*__int64(GetTotalDays()) - 3600*GetHours())/60);
  2041.   else
  2042.   {
  2043.     CLTimeSpan n(*this);
  2044.     n.Negate();
  2045.     return n.GetMinutes();
  2046.   }  
  2047. }
  2048.  
  2049. WORD CLTimeSpan::GetSeconds() const
  2050. {
  2051.   AssertValid();
  2052.  
  2053.   if (IsPositiveSpan())
  2054.     return (WORD) (m_nSeconds - 86400*__int64(GetTotalDays()) - 3600*GetHours() - 60*GetMinutes());
  2055.   else
  2056.   {
  2057.     CLTimeSpan n(*this);
  2058.     n.Negate();
  2059.     return n.GetSeconds();
  2060.   }  
  2061. }                             
  2062.  
  2063. BOOL CLTimeSpan::IsValid() const
  2064. {
  2065.   return m_bValid;
  2066. }
  2067.  
  2068. CLTimeSpan& CLTimeSpan::Negate()
  2069. {
  2070.   AssertValid();
  2071.   m_nSeconds = (-m_nSeconds);
  2072.   return *this;
  2073. }
  2074.  
  2075. BOOL CLTimeSpan::IsPositiveSpan() const
  2076. {
  2077.   AssertValid();
  2078.   return (m_nSeconds >= 0);
  2079. }
  2080.  
  2081. double CLTimeSpan::SecondsAsDouble() const
  2082. {
  2083.   AssertValid();
  2084.   return (double) m_nSeconds;
  2085. }
  2086.  
  2087. BOOL CLTimeSpan::operator==(const CLTimeSpan& TimeSpan) const
  2088. {
  2089.   AssertValid();
  2090.   return (m_nSeconds == TimeSpan.m_nSeconds);
  2091. }
  2092.  
  2093. BOOL CLTimeSpan::operator>(const CLTimeSpan& TimeSpan) const
  2094. {
  2095.   AssertValid();
  2096.   return (m_nSeconds > TimeSpan.m_nSeconds);
  2097. }
  2098.  
  2099. BOOL CLTimeSpan::operator>=(const CLTimeSpan& TimeSpan) const
  2100. {
  2101.   AssertValid();
  2102.   return (m_nSeconds >= TimeSpan.m_nSeconds);
  2103. }
  2104.  
  2105. BOOL CLTimeSpan::operator<(const CLTimeSpan& TimeSpan) const
  2106. {
  2107.   AssertValid();
  2108.   return (m_nSeconds < TimeSpan.m_nSeconds);
  2109. }
  2110.  
  2111. BOOL CLTimeSpan::operator<=(const CLTimeSpan& TimeSpan) const
  2112. {
  2113.   AssertValid();
  2114.   return (m_nSeconds <= TimeSpan.m_nSeconds);
  2115. }
  2116.  
  2117. BOOL CLTimeSpan::operator!=(const CLTimeSpan& TimeSpan) const
  2118. {
  2119.   AssertValid();
  2120.   return (m_nSeconds != TimeSpan.m_nSeconds);
  2121. }
  2122.                                  
  2123. CLTimeSpan& CLTimeSpan::operator=(const CLTimeSpan& TimeSpan)
  2124. { 
  2125.   m_nSeconds = TimeSpan.m_nSeconds;
  2126.   m_bValid = TimeSpan.m_bValid;
  2127.   return *this;
  2128. }
  2129.  
  2130. CLTimeSpan CLTimeSpan::operator+(const CLTimeSpan& TimeSpan) const
  2131. {
  2132.   AssertValid();
  2133.   TimeSpan.AssertValid();
  2134.   __int64 rVal = m_nSeconds + TimeSpan.m_nSeconds;
  2135.   return CLTimeSpan(rVal);
  2136. }
  2137.  
  2138. CLTimeSpan CLTimeSpan::operator-(const CLTimeSpan& TimeSpan) const
  2139. {
  2140.   AssertValid();
  2141.   TimeSpan.AssertValid();
  2142.   __int64 rVal = m_nSeconds - TimeSpan.m_nSeconds;
  2143.   return rVal;
  2144. }
  2145.  
  2146. CLTimeSpan& CLTimeSpan::operator+=(CLTimeSpan& TimeSpan)
  2147. {
  2148.   *this = *this + TimeSpan;
  2149.   return *this;
  2150. }
  2151.  
  2152. CLTimeSpan& CLTimeSpan::operator-=(CLTimeSpan& TimeSpan)
  2153. {
  2154.   *this = *this - TimeSpan;
  2155.   return *this;
  2156. }
  2157.  
  2158. CLTimeSpan operator-(const CLTimeSpan& TimeSpan)
  2159. {
  2160.   CLTimeSpan rVal(TimeSpan);
  2161.   return rVal.Negate();
  2162. }
  2163.  
  2164. CLTimeSpan CLTimeSpan::operator*(WORD Multiplier) const
  2165. {
  2166.   return ::operator*(Multiplier, *this);
  2167. }
  2168.  
  2169. CLTimeSpan operator*(WORD Multiplier, const CLTimeSpan& TimeSpan)
  2170. {
  2171.   TimeSpan.AssertValid();
  2172.   __int64 rVal = TimeSpan.m_nSeconds * Multiplier;
  2173.   return CLTimeSpan(rVal);
  2174. }
  2175.  
  2176. CLTimeSpan CLTimeSpan::operator/(WORD divisor) const
  2177. {
  2178.   AssertValid();
  2179.   __int64 rVal = m_nSeconds / divisor;
  2180.   return CLTimeSpan(rVal);
  2181. }
  2182.  
  2183. CLTimeSpan& CLTimeSpan::operator*=(WORD Multiplier)
  2184. {
  2185.   *this = operator*(Multiplier);
  2186.   return *this;
  2187. }
  2188.  
  2189. CLTimeSpan& CLTimeSpan::operator/=(WORD Divisor)
  2190. {
  2191.   *this = operator/(Divisor);
  2192.   return *this;
  2193. }
  2194.  
  2195. #ifdef _DEBUG
  2196. void CLTimeSpan::AssertValid() const
  2197. {
  2198.   CObject::AssertValid();
  2199.   ASSERT(IsValid());
  2200. }
  2201. #endif
  2202.  
  2203. #ifdef _DEBUG
  2204. void CLTimeSpan::Dump(CDumpContext& dc) const
  2205. {
  2206.   CObject::Dump(dc);
  2207.   if (IsValid())
  2208.     dc << Format() << _T("\n");
  2209.   else
  2210.     dc << _T("Invalid state\n");
  2211. }
  2212. #endif
  2213.  
  2214. /*    //The Following Format parameters are supported        
  2215. %D    Total days in this CLTimeSpan
  2216. %H    Hours in this CLTimeSpan (00 - 23)
  2217. %M    Minutes in the current hour in this CLTimeSpan (00 - 59)
  2218. %S    Seconds in the current minute in this CLTimeSpan (00 - 59)
  2219. %%    Percent sign
  2220. %#H, %#M, %#S  Remove leading zeros (if any).
  2221. */
  2222. CString CLTimeSpan::Format(const CString& sFormat) const
  2223. { 
  2224.   CString rVal;
  2225.   if (IsValid())
  2226.   {
  2227.     CString sBuffer;
  2228.     int sFmtLength = sFormat.GetLength();
  2229.  
  2230.     for (int i=0; i<sFmtLength; i++)
  2231.     {
  2232.       TCHAR c = sFormat.GetAt(i);
  2233.       if (c == _T('%'))
  2234.       {
  2235.         ++i;
  2236.         if (i < sFmtLength)
  2237.         {
  2238.           c = sFormat.GetAt(i);
  2239.           switch (c)
  2240.           {
  2241.             case _T('D'):
  2242.             {
  2243.               LONG Days = GetTotalDays();
  2244.               sBuffer.Format(_T("%ld"), Days);
  2245.               if (IsPositiveSpan())
  2246.                 rVal += _T("+");
  2247.               else if (Days == 0) //handle neagtive 0
  2248.                 rVal += _T("-");
  2249.               rVal += sBuffer;
  2250.               break;
  2251.             }
  2252.             case _T('H'):
  2253.             {
  2254.               sBuffer.Format(_T("%.02d"), GetHours());
  2255.               rVal += sBuffer;
  2256.               break;
  2257.             }
  2258.             case _T('M'):
  2259.             {
  2260.               sBuffer.Format(_T("%.02d"), GetMinutes());
  2261.               rVal += sBuffer;
  2262.               break;
  2263.             }
  2264.             case _T('S'):
  2265.             {
  2266.               sBuffer.Format(_T("%.02d"), GetSeconds());
  2267.               rVal += sBuffer;
  2268.               break;
  2269.             }
  2270.             case _T('#'):
  2271.             {
  2272.               if (i < sFmtLength)
  2273.               {
  2274.                 ++i;
  2275.                 c = sFormat.GetAt(i);
  2276.                 switch (c)
  2277.                 {
  2278.                   case _T('H'):
  2279.                   {
  2280.                     sBuffer.Format(_T("%d"), GetHours());
  2281.                     rVal += sBuffer;
  2282.                     break;
  2283.                   }
  2284.                   case _T('M'):
  2285.                   {
  2286.                     sBuffer.Format(_T("%d"), GetMinutes());
  2287.                     rVal += sBuffer;
  2288.                     break;
  2289.                   }
  2290.                   case _T('S'):
  2291.                   {
  2292.                     sBuffer.Format(_T("%d"), GetSeconds());
  2293.                     rVal += sBuffer;
  2294.                     break;
  2295.                   }
  2296.                   default:
  2297.                   {
  2298.                     rVal += c;
  2299.                     break;
  2300.                   }
  2301.                 }
  2302.               break;
  2303.               }
  2304.             }
  2305.             default:
  2306.             {
  2307.               rVal += c;
  2308.               break;
  2309.             }
  2310.           }
  2311.         }
  2312.       }
  2313.       else
  2314.       {
  2315.         rVal += c;
  2316.       }
  2317.     }
  2318.   }
  2319.   
  2320.   return rVal;
  2321. }
  2322.  
  2323. //Format according to the time format as specified by the control panel
  2324. CString CLTimeSpan::Format(DWORD dwFlags) const
  2325. {
  2326.   if (dwFlags & DTF_NOSECOND)
  2327.     return Format(sm_sDefaultFormatNOS);
  2328.   else
  2329.     return Format(sm_sDefaultFormat);
  2330. }
  2331.  
  2332. void CLTimeSpan::GetDefaultFormat()
  2333. {
  2334.   CString sBuf;
  2335.  
  2336.   // Is there to be a leading 0 on the Hour?
  2337.   BOOL bHourLZ = FALSE;
  2338.   LPTSTR pszBuf = sBuf.GetBuffer(10);
  2339.   int nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ITLZERO, pszBuf, 10);
  2340.   ASSERT(nChars);
  2341.   sBuf.ReleaseBuffer();
  2342.   if (sBuf == _T("0"))  //No leading zeros for hours
  2343.     bHourLZ = FALSE;
  2344.   else if (sBuf == _T("1"))  //Leading zeros for hours
  2345.     bHourLZ = TRUE;
  2346.   else
  2347.     ASSERT(FALSE);
  2348.  
  2349.   // Get the time separator character
  2350.   CString sSep(_T(":"));
  2351.   pszBuf = sSep.GetBuffer(10);
  2352.   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STIME, pszBuf, 10);
  2353.   ASSERT(nChars);
  2354.   sSep.ReleaseBuffer();
  2355.  
  2356.   //Modify behaviour depending on the various flags
  2357.   if (bHourLZ)
  2358.   {
  2359.     sm_sDefaultFormatNOS.Format(_T("%%D %%H%s%%M"), sSep);
  2360.     sm_sDefaultFormat.Format(_T("%%D %%H%s%%M%s%%S"), sSep, sSep);
  2361.   }
  2362.   else
  2363.   {
  2364.     sm_sDefaultFormatNOS.Format(_T("%%D %%#H%s%%M"), sSep);
  2365.     sm_sDefaultFormat.Format(_T("%%D %%#H%s%%M%s%%S"), sSep, sSep);
  2366.   }
  2367. }
  2368.  
  2369. void CLTimeSpan::Serialize(CArchive& ar)
  2370. {
  2371.   CObject::Serialize(ar);
  2372.  
  2373.   if (ar.IsStoring())
  2374.   {
  2375.     ar << m_nSeconds;
  2376.     ar << m_bValid;
  2377.   }
  2378.   else
  2379.   {
  2380.     ar >> m_nSeconds;
  2381.     ar >> m_bValid;
  2382.   }
  2383. }
  2384.  
  2385. ostream& operator<<(ostream &os, const CLTimeSpan& TimeSpan)
  2386. {
  2387.   return os << TimeSpan.Format();
  2388. }                  
  2389.  
  2390. CArchive& operator<<(CArchive& ar, CLTimeSpan& TimeSpan)
  2391. {
  2392.   ASSERT(ar.IsStoring());
  2393.   TimeSpan.Serialize(ar);
  2394.   return ar;
  2395. }
  2396.                
  2397. CArchive& operator>>(CArchive& ar, CLTimeSpan& TimeSpan)
  2398. {
  2399.   ASSERT(!ar.IsStoring());
  2400.   TimeSpan.Serialize(ar);
  2401.   return ar;
  2402. }
  2403.  
  2404.  
  2405.  
  2406.  
  2407.  
  2408.  
  2409. //CLTimeOfDay Implementation
  2410.  
  2411. CLTimeOfDay::CLTimeOfDay()
  2412. {
  2413.   Set();
  2414. }
  2415.  
  2416. CLTimeOfDay::CLTimeOfDay(WORD Hour, WORD Minute, WORD Second)
  2417. {
  2418.   Set(Hour, Minute, Second);
  2419. }    
  2420.  
  2421. CLTimeOfDay::CLTimeOfDay(const SYSTEMTIME& st)
  2422. {        
  2423.   Set(st);
  2424. }
  2425.            
  2426. CLTimeOfDay::CLTimeOfDay(const CLTimeOfDay& ltod)
  2427. {
  2428.   m_dwTotalSeconds = ltod.m_dwTotalSeconds;
  2429.   m_bValid = ltod.m_bValid;
  2430. }                                
  2431.  
  2432. CLTimeOfDay::CLTimeOfDay(DWORD TotalSeconds)
  2433. {
  2434.   Set(TotalSeconds);
  2435. }                                
  2436.  
  2437.  
  2438. CLTimeOfDay& CLTimeOfDay::Set()
  2439. {
  2440.   m_dwTotalSeconds = 0;
  2441.   m_bValid = FALSE;
  2442.   return *this;
  2443. }
  2444.  
  2445. CLTimeOfDay& CLTimeOfDay::Set(WORD Hour, WORD Minute, WORD Second)
  2446. {
  2447.   m_dwTotalSeconds = Hour*3600 + Minute*60 + Second;
  2448.   if (m_dwTotalSeconds >= 86400L)
  2449.   {
  2450.     if (sm_bDoAsserts)
  2451.       ASSERT(FALSE);
  2452.     Set();
  2453.     return *this;
  2454.   }
  2455.  
  2456.   m_bValid = TRUE;
  2457.   return *this;  
  2458. }                
  2459.  
  2460. CLTimeOfDay& CLTimeOfDay::Set(const SYSTEMTIME& st)
  2461. {        
  2462.   return Set(st.wHour, st.wMinute, st.wSecond);
  2463. }
  2464.                                  
  2465. CLTimeOfDay& CLTimeOfDay::Set(DWORD TotalSeconds)
  2466. {
  2467.   m_dwTotalSeconds = TotalSeconds;
  2468.   if (m_dwTotalSeconds >= 86400)
  2469.   {
  2470.     if (sm_bDoAsserts)
  2471.       ASSERT(FALSE);
  2472.     Set();
  2473.     return *this;
  2474.   }
  2475.  
  2476.   m_bValid = TRUE;
  2477.   return *this;  
  2478. }
  2479.                                  
  2480. CLTimeOfDay CLTimeOfDay::CurrentTimeOfDay(TimeFrame tf)
  2481. { 
  2482.   SYSTEMTIME st;                                
  2483.   switch (tf)
  2484.   {    
  2485.     case UCT:
  2486.       ::GetSystemTime(&st); 
  2487.       break;
  2488.     case LOCAL:
  2489.       ::GetLocalTime(&st); 
  2490.       break;   
  2491.     case ET:
  2492.       ASSERT(FALSE);
  2493.       break;
  2494.     default: ASSERT(FALSE);
  2495.   }    
  2496.       
  2497.   return CLTimeOfDay(st);
  2498. }
  2499.                                  
  2500. CLTimeOfDay CLTimeOfDay::Midnight()
  2501. {
  2502.   return CLTimeOfDay(0, 0, 0);
  2503. }
  2504.  
  2505. CLTimeOfDay CLTimeOfDay::Midday()
  2506. {
  2507.   return CLTimeOfDay(12, 0, 0);
  2508. }
  2509.  
  2510. #ifdef _DEBUG
  2511. BOOL CLTimeOfDay::SetDoConstructorAsserts(BOOL bDoAsserts)
  2512. {
  2513.   BOOL bOldDoAsserts = sm_bDoAsserts;
  2514.   sm_bDoAsserts = bDoAsserts;
  2515.   return bOldDoAsserts;
  2516. }
  2517. #endif                 
  2518.  
  2519. WORD CLTimeOfDay::GetHour() const
  2520. {
  2521.   AssertValid();
  2522.   return (WORD) (m_dwTotalSeconds/3600L);
  2523. }
  2524.  
  2525. WORD CLTimeOfDay::GetMinute() const
  2526. {
  2527.   AssertValid();
  2528.   return (WORD) ((m_dwTotalSeconds - (GetHour()*3600L))/60);
  2529. }
  2530.  
  2531. DWORD CLTimeOfDay::GetTotalSeconds() const
  2532. {
  2533.   AssertValid();
  2534.   return m_dwTotalSeconds;
  2535. }
  2536.  
  2537. WORD CLTimeOfDay::GetSecond() const
  2538. {
  2539.   AssertValid();
  2540.   return (WORD) (m_dwTotalSeconds - (60L * (GetMinute() + (60L*GetHour()))));
  2541. }                                                                
  2542.  
  2543. WORD CLTimeOfDay::GetAMPMHour() const
  2544. {
  2545.   AssertValid();
  2546.   WORD wHour = GetHour();
  2547.   if (wHour > 12)
  2548.     wHour -= 12;
  2549.   return wHour;
  2550. }                             
  2551.  
  2552. CString CLTimeOfDay::GetAMString()
  2553. {
  2554.   CString rVal;
  2555.   LPTSTR pszBuf = rVal.GetBuffer(20);
  2556.   int nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_S1159, pszBuf, 20);
  2557.   rVal.ReleaseBuffer();
  2558.   return rVal;
  2559. }
  2560.  
  2561. CString CLTimeOfDay::GetPMString()
  2562. {
  2563.   CString rVal;
  2564.   LPTSTR pszBuf = rVal.GetBuffer(20);
  2565.   int nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_S2359, pszBuf, 20);
  2566.   rVal.ReleaseBuffer();
  2567.   return rVal;
  2568. }
  2569.  
  2570. CString CLTimeOfDay::GetAMPMString() const
  2571. {
  2572.   AssertValid();
  2573.   if (GetHour() > 12)
  2574.     return GetPMString();
  2575.   else
  2576.     return GetAMString();
  2577. }
  2578.  
  2579. BOOL CLTimeOfDay::IsValid() const
  2580. {                  
  2581.   return m_bValid;
  2582. }
  2583.  
  2584. DWORD CLTimeOfDay::Collate() const
  2585. {
  2586.   AssertValid();
  2587.   DWORD rVal = GetHour()*10000L + GetMinute()*100L + GetSecond();
  2588.   return rVal;
  2589. }
  2590.  
  2591. SYSTEMTIME CLTimeOfDay::GetSYSTEMTIME() const
  2592. {
  2593.   AssertValid();
  2594.   SYSTEMTIME st;
  2595.  
  2596.   st.wYear=0;
  2597.   st.wMonth=0;
  2598.   st.wDayOfWeek=0;
  2599.   st.wDay=0;
  2600.   st.wHour = GetHour();
  2601.   st.wMinute = GetMinute();
  2602.   st.wSecond = GetSecond();
  2603.   st.wMilliseconds = 0;
  2604.   return st;
  2605. }
  2606.  
  2607. tm CLTimeOfDay::GetTM() const
  2608. {
  2609.   AssertValid();
  2610.   tm rVal;
  2611.   
  2612.   rVal.tm_hour  = GetHour();
  2613.   rVal.tm_min   = GetMinute();
  2614.   rVal.tm_sec   = GetSecond();
  2615.   rVal.tm_mday  = 0;
  2616.   rVal.tm_mon   = 0;
  2617.   rVal.tm_year  = 0;
  2618.   rVal.tm_wday  = 0;
  2619.   rVal.tm_yday  = 0;
  2620.   rVal.tm_isdst = 0;
  2621.               
  2622.   return rVal;
  2623. }
  2624.  
  2625. CLTimeOfDay& CLTimeOfDay::operator=(const CLTimeOfDay& Tod)
  2626. {               
  2627.   m_dwTotalSeconds = Tod.m_dwTotalSeconds;
  2628.   m_bValid = Tod.m_bValid;
  2629.   return *this;
  2630. }
  2631.  
  2632. CLTimeOfDay CLTimeOfDay::operator+(const CLTimeSpan& TimeSpan) const
  2633. {
  2634.   AssertValid();
  2635.   CLTimeSpan t = CLTimeSpan(*this) + CLTimeSpan(0, TimeSpan.GetHours(), TimeSpan.GetMinutes(),
  2636.                             TimeSpan.GetSeconds());
  2637.   return CLTimeOfDay(t.GetHours(), t.GetMinutes(), t.GetSeconds());
  2638. }
  2639.  
  2640. CLTimeOfDay CLTimeOfDay::operator-(const CLTimeSpan& TimeSpan) const
  2641. {
  2642.   AssertValid();
  2643.   //Addition of 1 Day is used to ensure result "t" does not go negative
  2644.   CLTimeSpan t = CLTimeSpan::OneDay() + CLTimeSpan(*this) - 
  2645.                  CLTimeSpan(0, TimeSpan.GetHours(), TimeSpan.GetMinutes(),
  2646.                             TimeSpan.GetSeconds());
  2647.   return CLTimeOfDay(t.GetHours(), t.GetMinutes(), t.GetSeconds());
  2648. }
  2649.  
  2650. CLTimeOfDay& CLTimeOfDay::operator+=(CLTimeSpan& TimeSpan)
  2651. {
  2652.   *this = *this + TimeSpan;
  2653.   return *this;
  2654. }
  2655.  
  2656. CLTimeOfDay& CLTimeOfDay::operator-=(CLTimeSpan& TimeSpan)
  2657. {
  2658.   *this = *this - TimeSpan;
  2659.   return *this;
  2660. }
  2661.  
  2662. BOOL CLTimeOfDay::operator==(const CLTimeOfDay& Tod) const
  2663. {
  2664.   AssertValid();
  2665.   return (m_dwTotalSeconds == Tod.m_dwTotalSeconds);
  2666. }
  2667.  
  2668. BOOL CLTimeOfDay::operator>(const CLTimeOfDay& Tod) const
  2669. {               
  2670.   AssertValid();
  2671.   return (m_dwTotalSeconds > Tod.m_dwTotalSeconds);
  2672. }
  2673.  
  2674. BOOL CLTimeOfDay::operator>=(const CLTimeOfDay& Tod) const
  2675. {               
  2676.   AssertValid();
  2677.   return (m_dwTotalSeconds >= Tod.m_dwTotalSeconds);
  2678. }
  2679.  
  2680. BOOL CLTimeOfDay::operator<(const CLTimeOfDay& Tod) const
  2681. {             
  2682.   AssertValid();
  2683.   return (m_dwTotalSeconds < Tod.m_dwTotalSeconds);
  2684. }
  2685.  
  2686. BOOL CLTimeOfDay::operator<=(const CLTimeOfDay& Tod) const
  2687. {
  2688.   AssertValid();
  2689.   return (m_dwTotalSeconds <= Tod.m_dwTotalSeconds);
  2690. }
  2691.  
  2692. BOOL CLTimeOfDay::operator!=(const CLTimeOfDay& Tod) const
  2693. {               
  2694.   AssertValid();                  
  2695.   return !operator==(Tod);
  2696. }
  2697.  
  2698. #ifdef _DEBUG
  2699. void CLTimeOfDay::AssertValid() const
  2700. {
  2701.   CObject::AssertValid();
  2702.   ASSERT(IsValid());
  2703. }
  2704. #endif
  2705.  
  2706. #ifdef _DEBUG
  2707. void CLTimeOfDay::Dump(CDumpContext& dc) const
  2708. {
  2709.   CObject::Dump(dc);
  2710.   if (IsValid())
  2711.     dc << Format() << _T("\n");
  2712.   else
  2713.     dc << _T("Invalid state\n");
  2714. }
  2715. #endif                       
  2716.  
  2717. /*    //The Following Format parameters are supported        
  2718.  
  2719. %H    Hours in the current day
  2720. %M    Minutes in the current hour
  2721. %h    12 Hour format Hours in this CLTimeSpan (00 - 12)
  2722. %P    AM / PM indicator
  2723. %S    Seconds in the current minute
  2724. %%    Percent sign       
  2725. %x    Time Of Day representation for current locale        
  2726. %#H, %#h, %#M, %#S  Remove leading zeros (if any).
  2727. */
  2728. CString CLTimeOfDay::Format(const CString& sFormat) const
  2729. { 
  2730.   CString rVal;
  2731.   if (IsValid())
  2732.   {
  2733.     CString sBuffer;
  2734.     int sFmtLength = sFormat.GetLength();
  2735.  
  2736.     for (int i=0; i<sFmtLength; i++)
  2737.     {
  2738.       TCHAR c = sFormat.GetAt(i);
  2739.       if (c == _T('%'))
  2740.       {
  2741.         ++i;
  2742.         if (i < sFmtLength)
  2743.         {
  2744.           c = sFormat.GetAt(i);
  2745.           switch (c)
  2746.           {
  2747.             case _T('H'):
  2748.             {
  2749.               sBuffer.Format(_T("%.02d"), GetHour());
  2750.               rVal += sBuffer;
  2751.               break;
  2752.             }
  2753.             case _T('M'):
  2754.             {
  2755.               sBuffer.Format(_T("%.02d"), GetMinute());
  2756.               rVal += sBuffer;
  2757.               break;
  2758.             }
  2759.             case _T('h'):
  2760.             {
  2761.               sBuffer.Format(_T("%.02d"), GetAMPMHour());
  2762.               rVal += sBuffer;
  2763.               break;
  2764.             }
  2765.             case _T('P'):
  2766.             {
  2767.               rVal += GetAMPMString();
  2768.               break;
  2769.             }
  2770.             case _T('S'):
  2771.             {
  2772.               sBuffer.Format(_T("%.02d"), GetSecond());
  2773.               rVal += sBuffer;
  2774.               break;
  2775.             }
  2776.             case _T('x'):                                      
  2777.             {
  2778.               sBuffer.Empty();
  2779.               SYSTEMTIME st = GetSYSTEMTIME();
  2780.               int Res = ::GetTimeFormat(LOCALE_USER_DEFAULT,
  2781.                                       LOCALE_NOUSEROVERRIDE,
  2782.                                       &st,
  2783.                                       NULL,
  2784.                                       sBuffer.GetBufferSetLength(100),
  2785.                                       100); 
  2786.               if (Res == 0)
  2787.                 TRACE1("GetDateFormat() Failed in CLTimeSpan::Format(), GetLastError() returned %ul\n", ::GetLastError());
  2788.               sBuffer.ReleaseBuffer();
  2789.               rVal += sBuffer;
  2790.               break;
  2791.             }
  2792.             case _T('#'):
  2793.             {
  2794.               if (i < sFmtLength)
  2795.               {
  2796.                 ++i;
  2797.                 c = sFormat.GetAt(i);
  2798.                 switch (c)
  2799.                 {
  2800.                   case _T('H'):
  2801.                   {
  2802.                     sBuffer.Format(_T("%d"), GetHour());
  2803.                     rVal += sBuffer;
  2804.                     break;
  2805.                   }
  2806.                   case _T('h'):
  2807.                   {
  2808.                     sBuffer.Format(_T("%d"), GetAMPMHour());
  2809.                     rVal += sBuffer;
  2810.                     break;
  2811.                   }
  2812.                   case _T('M'):
  2813.                   {
  2814.                     sBuffer.Format(_T("%d"), GetMinute());
  2815.                     rVal += sBuffer;
  2816.                     break;
  2817.                   }
  2818.                   case _T('S'):
  2819.                   {
  2820.                     sBuffer.Format(_T("%d"), GetSecond());
  2821.                     rVal += sBuffer;
  2822.                     break;
  2823.                   }
  2824.                   default:
  2825.                   {
  2826.                     rVal += c;
  2827.                     break;
  2828.                   }
  2829.                 }
  2830.               }
  2831.               break;
  2832.             }
  2833.             default:
  2834.             {
  2835.               rVal += c;
  2836.               break;
  2837.             }
  2838.           }
  2839.         }
  2840.       }
  2841.       else
  2842.       {
  2843.         rVal += c;
  2844.       }
  2845.     }
  2846.   }
  2847.   return rVal;
  2848. }
  2849.  
  2850. //Format according to the time format as specified by the control panel
  2851. CString CLTimeOfDay::Format(DWORD dwFlags) const
  2852. {
  2853.   if (dwFlags & DTF_NOSECOND)
  2854.     return Format(sm_sDefaultFormatNOS);
  2855.   else
  2856.     return Format(sm_sDefaultFormat);
  2857. }
  2858.  
  2859. void CLTimeOfDay::GetDefaultFormat()
  2860. {
  2861.   CString sBuf;
  2862.  
  2863.   // Is there to be a leading 0 on the Hour?
  2864.   BOOL bHourLZ = FALSE;
  2865.   LPTSTR pszBuf = sBuf.GetBuffer(10);
  2866.   int nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ITLZERO, pszBuf, 10);
  2867.   ASSERT(nChars);
  2868.   sBuf.ReleaseBuffer();
  2869.   if (sBuf == _T("0"))  //No leading zeros for hours
  2870.     bHourLZ = FALSE;
  2871.   else if (sBuf == _T("1"))  //Leading zeros for hours
  2872.     bHourLZ = TRUE;
  2873.   else
  2874.     ASSERT(FALSE);
  2875.  
  2876.   // Get the time separator character
  2877.   CString sSep(_T(":"));
  2878.   pszBuf = sSep.GetBuffer(10);
  2879.   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STIME, pszBuf, 10);
  2880.   ASSERT(nChars);
  2881.   sSep.ReleaseBuffer();
  2882.  
  2883.   //Get the 24 Hour / 12 Hour indicator
  2884.   BOOL b24Hour = FALSE;
  2885.   pszBuf = sBuf.GetBuffer(10);
  2886.   nChars = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ITIME, pszBuf, 10);
  2887.   ASSERT(nChars);
  2888.   sBuf.ReleaseBuffer();
  2889.   if (sBuf == _T("0"))  //AM / PM Style
  2890.     b24Hour = FALSE;
  2891.   else if (sBuf == _T("1"))  //24 Hour Style
  2892.     b24Hour = TRUE;
  2893.   else
  2894.     ASSERT(FALSE);
  2895.  
  2896.  
  2897.   //Modify behaviour depending on the various flags
  2898.   if (bHourLZ)
  2899.   {
  2900.     if (b24Hour)
  2901.     {
  2902.       sm_sDefaultFormatNOS.Format(_T("%%H%s%%M"), sSep);
  2903.       sm_sDefaultFormat.Format(_T("%%H%s%%M%s%%S"), sSep, sSep);
  2904.     }
  2905.     else
  2906.     {
  2907.       sm_sDefaultFormatNOS.Format(_T("%%h%s%%M %%P"), sSep);
  2908.       sm_sDefaultFormat.Format(_T("%%h%s%%M%s%%S %%P"), sSep, sSep);
  2909.     }
  2910.   }
  2911.   else
  2912.   {
  2913.     if (b24Hour)
  2914.     {
  2915.       sm_sDefaultFormatNOS.Format(_T("%%#H%s%%M"), sSep, sSep);
  2916.       sm_sDefaultFormat.Format(_T("%%#H%s%%M%s%%S"), sSep, sSep, sSep);
  2917.     }
  2918.     else
  2919.     {
  2920.       sm_sDefaultFormatNOS.Format(_T("%%#h%s%%M %%P"), sSep, sSep);
  2921.       sm_sDefaultFormat.Format(_T("%%#h%s%%M%s%%S %%P"), sSep, sSep, sSep);
  2922.     }
  2923.   }
  2924. }
  2925.  
  2926. void CLTimeOfDay::Serialize(CArchive& ar)
  2927. {
  2928.   CObject::Serialize(ar);
  2929.  
  2930.   if (ar.IsStoring())
  2931.   {
  2932.     ar << m_dwTotalSeconds;
  2933.     ar << m_bValid;
  2934.   }
  2935.   else
  2936.   {
  2937.     ar >> m_dwTotalSeconds;
  2938.     ar >> m_bValid;
  2939.   }
  2940. }
  2941.  
  2942. ostream& operator<<(ostream &os, const CLTimeOfDay &TimeOfDay)
  2943. {
  2944.   return os << TimeOfDay.Format();
  2945. }                       
  2946.  
  2947. CArchive& operator<<(CArchive& ar, CLTimeOfDay &TimeOfDay)
  2948. {
  2949.   ASSERT(ar.IsStoring());
  2950.   TimeOfDay.Serialize(ar);
  2951.   return ar;
  2952. }
  2953.  
  2954. CArchive& operator>>(CArchive& ar, CLTimeOfDay &TimeOfDay)
  2955. {
  2956.   ASSERT(!ar.IsStoring());
  2957.   TimeOfDay.Serialize(ar);
  2958.   return ar;
  2959. }
  2960.  
  2961.  
  2962.  
  2963.  
  2964.  
  2965.  
  2966. //CLDate implementation
  2967.  
  2968.  
  2969. CLDate::CLDate()
  2970. {
  2971.   Set();
  2972. }
  2973.   
  2974. CLDate::CLDate(LONG Year, WORD Month, WORD Day, 
  2975.                WORD Hour, WORD Minute, WORD Second,
  2976.                TimeFrame tf)
  2977. {
  2978.   Set(Year, Month, Day, Hour, Minute, Second, tf);
  2979. }                                            
  2980.  
  2981. CLDate::CLDate(const SYSTEMTIME& st, TimeFrame tf, BOOL bUseDayOfWeek)
  2982. { 
  2983.   Set(st, tf, bUseDayOfWeek);
  2984. } 
  2985.  
  2986. CLDate::CLDate(LONG Year, WORD Month, WORD WeekOfMonth,
  2987.                WORD DayOfWeek, WORD Hour, WORD Minute, WORD Second,
  2988.                TimeFrame tf)
  2989. {
  2990.   Set(Year, Month, WeekOfMonth, DayOfWeek, Hour, Minute, Second, tf);
  2991. }
  2992.                
  2993. CLDate::CLDate(LONG Days, CDate::DateEpoch e, WORD Hour, WORD Minute,
  2994.                WORD Second, TimeFrame tf)
  2995. {
  2996.   Set(Days, e, Hour, Minute, Second, tf);
  2997. } 
  2998.  
  2999. CLDate::CLDate(const CDate& Date, const CLTimeOfDay& Tod, TimeFrame tf)
  3000. { 
  3001.   Set(Date, Tod, tf);
  3002. }
  3003.  
  3004.  
  3005. CLDate::CLDate(const CLDate& ld)
  3006. {                                 
  3007.   m_nSeconds  = ld.m_nSeconds;
  3008.   m_bValid    = ld.m_bValid;
  3009.   m_TimeFrame = ld.m_TimeFrame;
  3010. }
  3011.  
  3012. CLDate::CLDate(const CTime& ct)
  3013. {
  3014.   Set(ct);
  3015. }
  3016.       
  3017. CLDate::CLDate(const COleDateTime& oleTime, TimeFrame tf)
  3018. {
  3019.   Set(oleTime, tf);
  3020. }                     
  3021.  
  3022. CLDate& CLDate::Set()
  3023. {
  3024.   m_nSeconds = 0;
  3025.   m_bValid = FALSE;
  3026.   return *this;
  3027. }
  3028.  
  3029. CLDate& CLDate::Set(LONG Year, WORD Month, WORD Day,
  3030.                     WORD Hour, WORD Minute, WORD Second,
  3031.                     TimeFrame tf)
  3032. {              
  3033.   CDate Date(Year, Month, Day);
  3034.   CLTimeOfDay Tod(Hour, Minute, Second);
  3035.  
  3036.   m_TimeFrame = tf;
  3037.   m_nSeconds = __int64(Date.GetValue())*86400 + Tod.GetTotalSeconds();
  3038.   m_bValid = TRUE;
  3039.  
  3040.   if (tf == LOCAL)
  3041.     CheckForValidLocalDate();
  3042.   return *this;
  3043. }
  3044.                     
  3045. CLDate& CLDate::Set(const SYSTEMTIME& st, TimeFrame tf, BOOL bUseDayOfWeek)
  3046. {
  3047.   if (bUseDayOfWeek)  //Using Day-in-month format
  3048.   {
  3049.     if (st.wYear)     //an absolute year, wDayOfWeek is 0 based
  3050.       Set(st.wYear, st.wMonth, st.wDay, (WORD)(st.wDayOfWeek+1), st.wHour, 
  3051.           st.wMinute, st.wSecond, tf);
  3052.     else              //use the current year
  3053.       Set(CurrentTime(tf).GetCDate().GetYear(), st.wMonth, st.wDay, 
  3054.           (WORD)(st.wDayOfWeek+1), st.wHour, st.wMinute, st.wSecond, tf);
  3055.   }
  3056.   else
  3057.   {
  3058.     if (st.wYear)     //an absolute year
  3059.       Set(st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, tf);
  3060.     else              //use the current year
  3061.       Set(CurrentTime(tf).GetCDate().GetYear(), st.wMonth, st.wDay, 
  3062.           st.wHour, st.wMinute, st.wSecond, tf);
  3063.   }
  3064.  
  3065.   return *this;
  3066. }
  3067.  
  3068.  
  3069. CLDate& CLDate::Set(LONG Year, WORD Month, WORD WeekOfMonth, 
  3070.                     WORD DayOfWeek, WORD Hour, WORD Minute, WORD Second,
  3071.                     TimeFrame tf)
  3072. {
  3073.   CDate Date(Year, Month, WeekOfMonth, DayOfWeek);
  3074.   CLTimeOfDay Tod(Hour, Minute, Second);
  3075.  
  3076.   m_TimeFrame = tf;
  3077.   m_nSeconds = __int64(Date.GetValue())*86400 + Tod.GetTotalSeconds();
  3078.   m_bValid = TRUE;
  3079.  
  3080.   if (tf == LOCAL)
  3081.     CheckForValidLocalDate();
  3082.   return *this;
  3083. }
  3084.                     
  3085. CLDate& CLDate::Set(LONG Days, CDate::DateEpoch e, WORD Hour, WORD Minute,
  3086.                     WORD Second, TimeFrame tf)
  3087. {
  3088.   CDate Date(Days, e);
  3089.   CLTimeOfDay Tod(Hour, Minute, Second);
  3090.  
  3091.   m_TimeFrame = tf;
  3092.   m_nSeconds = __int64(Date.GetValue())*86400 + Tod.GetTotalSeconds();
  3093.   m_bValid = TRUE;
  3094.  
  3095.   if (tf == LOCAL)
  3096.     CheckForValidLocalDate();
  3097.   return *this;
  3098. }
  3099.  
  3100. CLDate& CLDate::Set(const CTime& ct)
  3101. {
  3102.   m_TimeFrame = UCT;
  3103.   tm* pTM = ct.GetGmtTm();
  3104.   Set(pTM->tm_year + 1900, (WORD) (pTM->tm_mon+1), (WORD) pTM->tm_mday, 
  3105.          (WORD) pTM->tm_hour, (WORD) pTM->tm_min, (WORD) pTM->tm_sec, UCT);
  3106.   return *this;  
  3107. }
  3108.  
  3109. CLDate& CLDate::Set(const CDate& Date, const CLTimeOfDay& Tod, TimeFrame tf)
  3110. {
  3111.   if (!Date.IsValid() || !Tod.IsValid())
  3112.     Set();
  3113.   else
  3114.   {
  3115.     m_TimeFrame = tf;
  3116.     m_nSeconds = __int64(Date.GetValue())*86400 + Tod.GetTotalSeconds();
  3117.     m_bValid = TRUE;
  3118.  
  3119.     if (tf == LOCAL)
  3120.       CheckForValidLocalDate();
  3121.   }
  3122.  
  3123.   return *this;  
  3124. }
  3125.       
  3126. CLDate& CLDate::Set(const COleDateTime& oleTime, TimeFrame tf)
  3127. {
  3128.   COleDateTime::DateTimeStatus dts(oleTime.GetStatus());
  3129.   if (dts == COleDateTime::DateTimeStatus::valid)
  3130.     Set((LONG) oleTime.GetYear(), (WORD) oleTime.GetMonth(), (WORD) oleTime.GetDay(),
  3131.         (WORD) oleTime.GetHour(), (WORD) oleTime.GetMinute(), (WORD) oleTime.GetSecond(), tf);
  3132.   else
  3133.     Set();
  3134.   return *this;
  3135. }                     
  3136.  
  3137. void CLDate::CheckForValidLocalDate()
  3138. {
  3139.   //Should only be called when tested a LOCAL CLDate
  3140.   ASSERT(m_TimeFrame == LOCAL);
  3141.  
  3142.   TIME_ZONE_INFORMATION tzi;
  3143.   BOOL bSuccess = (::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  3144.   ASSERT(bSuccess);
  3145.   
  3146.   //Set the TimeFrame to UCT so that we do not need to perform DST conversions in
  3147.   //the following arithmetic
  3148.   m_TimeFrame = UCT;
  3149.  
  3150.   CLDate BeginDaylightTime;
  3151.   LONG ThisYear = GetCDate().GetYear();
  3152.   if (tzi.DaylightDate.wYear == 0)  //Using Day-in-month format
  3153.     BeginDaylightTime.Set(ThisYear, tzi.DaylightDate.wMonth, tzi.DaylightDate.wDay, (WORD)(tzi.DaylightDate.wDayOfWeek+1),
  3154.                           tzi.DaylightDate.wHour, tzi.DaylightDate.wMinute, tzi.DaylightDate.wSecond, UCT);
  3155.   else
  3156.     BeginDaylightTime.Set(tzi.DaylightDate.wYear, tzi.DaylightDate.wMonth, tzi.DaylightDate.wDay, tzi.DaylightDate.wHour,
  3157.                           tzi.DaylightDate.wMinute, tzi.DaylightDate.wSecond, UCT);
  3158.  
  3159.   CLDate BeginStandardTime;
  3160.   if (tzi.StandardDate.wYear == 0)  //Using Day-in-month format
  3161.     BeginStandardTime.Set(ThisYear, tzi.StandardDate.wMonth, tzi.StandardDate.wDay, (WORD)(tzi.StandardDate.wDayOfWeek+1),
  3162.                           tzi.StandardDate.wHour, tzi.StandardDate.wMinute, tzi.StandardDate.wSecond, UCT);
  3163.   else
  3164.     BeginStandardTime.Set(tzi.StandardDate.wYear, tzi.StandardDate.wMonth, tzi.StandardDate.wDay, tzi.StandardDate.wHour, 
  3165.                           tzi.StandardDate.wMinute, tzi.StandardDate.wSecond, UCT);
  3166.  
  3167.  
  3168. #ifdef _DEBUG
  3169.   CString s = BeginDaylightTime.Format();
  3170.   s = BeginStandardTime.Format();
  3171. #endif
  3172.  
  3173.   if (tzi.DaylightBias > 0)
  3174.   {
  3175.     //A CLDate which specifies a date which occurs twice
  3176.     CLDate StartNonUnique(BeginDaylightTime - CLTimeSpan(0, 0, (WORD) tzi.DaylightBias, 0));
  3177.     if ((*this >= StartNonUnique) && (*this < BeginDaylightTime))
  3178.     {
  3179.       TRACE0("A CLDate using a LOCAL timeframe tried to be constructed which represents a non unique absolute time\n"); 
  3180.       if (sm_bDoAsserts)
  3181.         ASSERT(FALSE);
  3182.       Set();
  3183.       return;
  3184.     }
  3185.  
  3186.     //A CLDate which specifies a date which does not occur
  3187.     CLDate EndSkip(BeginStandardTime + CLTimeSpan(0, 0, (WORD) tzi.DaylightBias, 0));
  3188.     if ((*this > BeginStandardTime) && (*this < EndSkip))
  3189.     {
  3190.       TRACE0("A CLDate using a LOCAL timeframe tried to be constructed which does not occur\n");
  3191.       if (sm_bDoAsserts)
  3192.         ASSERT(FALSE);
  3193.       Set();
  3194.       return;
  3195.     }
  3196.  
  3197.   }
  3198.   else if (tzi.DaylightBias < 0)
  3199.   {
  3200.     //A CLDate which specifies a date which does not occur
  3201.     CLDate EndSkip(BeginDaylightTime + CLTimeSpan(0, 0, (WORD) -tzi.DaylightBias, 0));
  3202.     if ((*this > BeginDaylightTime) && (*this < EndSkip))
  3203.     {
  3204.       TRACE0("A CLDate using a LOCAL timeframe tried to be constructed which does not occur\n"); 
  3205.       if (sm_bDoAsserts)
  3206.         ASSERT(FALSE);
  3207.       Set();
  3208.       return;
  3209.     }
  3210.  
  3211.     //A CLDate which specifies a date which occurs twice
  3212.     CLDate StartNonUnique(BeginStandardTime - CLTimeSpan(0, 0, (WORD) -tzi.DaylightBias, 0));
  3213.     if ((*this >= StartNonUnique) && 
  3214.         (*this <= BeginStandardTime) )
  3215.     {
  3216.       TRACE0("A CLDate using a LOCAL timeframe tried to be constructed which represents a non unique absolute time\n"); 
  3217.       if (sm_bDoAsserts)
  3218.         ASSERT(FALSE);
  3219.       Set();
  3220.       return;
  3221.     }
  3222.   }
  3223.  
  3224.   //return the timeframe back to local
  3225.   m_TimeFrame = LOCAL;
  3226. }
  3227.                     
  3228. CLDate CLDate::CurrentTime(TimeFrame tf)
  3229. {                                      
  3230.   SYSTEMTIME st;
  3231.   ::GetSystemTime(&st);
  3232.   CLDate rVal(st, UCT);
  3233.   rVal.SetTimeFrame(tf);
  3234.   return rVal; 
  3235. }
  3236.  
  3237. CLTimeSpan CLDate::DeltaT(CLDate& d)
  3238. {
  3239.   CLTimeSpan Tspan(d - CLDate(CDate::Epoch2000(), CLTimeOfDay(0, 0, 0), d.GetTimeFrame()));
  3240.   double T = Tspan.GetTotalDays()/36525.0;
  3241.   double S;
  3242.  
  3243.   double y = 2000 + T * 100;
  3244.   if (y > 2000)
  3245.     S = 102.3 + T * (123.5 + T * 32.5);
  3246.   else if (y < 1620)
  3247.   {
  3248.     if (y < 948)
  3249.       S = 2715.6 + T * (573.36 + T * 46.5);
  3250.     else 
  3251.       S = 50.6 + T * (67.5 + T * 22.5);
  3252.   }
  3253.   else /* Interpolate from the static data table */
  3254.   {
  3255.     int Index = (int)((y - 1620) / 2);
  3256.     if (Index > 185)
  3257.       Index = 185;
  3258.     y = y / 2 - Index - 810;
  3259.     S = (DeltaTTable[Index] + (DeltaTTable[Index + 1] - DeltaTTable[Index]) * y) / 10;
  3260.   }
  3261.  
  3262.   return CLTimeSpan(S);
  3263. }
  3264.  
  3265. BOOL CLDate::CurrentlyInDST()
  3266. {
  3267.   TIME_ZONE_INFORMATION tzi;
  3268.   return ::GetTimeZoneInformation(&tzi) == TIME_ZONE_ID_DAYLIGHT;
  3269. }
  3270.  
  3271. CLTimeSpan CLDate::DaylightBias()
  3272. {
  3273.   TIME_ZONE_INFORMATION tzi;
  3274.   BOOL bSuccess = (::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  3275.   ASSERT(bSuccess);
  3276.  
  3277.   CLTimeSpan rVal;
  3278.   if (tzi.DaylightBias > 0)
  3279.     rVal = CLTimeSpan(0, 0, (WORD) tzi.DaylightBias, 0);
  3280.   else
  3281.   {
  3282.     rVal = CLTimeSpan(0, 0, (WORD) -tzi.DaylightBias, 0);
  3283.     rVal.Negate();
  3284.   }
  3285.   return rVal;
  3286. }
  3287.  
  3288. CLTimeSpan CLDate::TimezoneBias()
  3289. {
  3290.   TIME_ZONE_INFORMATION tzi;
  3291.   BOOL bSuccess = (::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  3292.   ASSERT(bSuccess);
  3293.  
  3294.   CLTimeSpan rVal;
  3295.   LONG tzBias = tzi.StandardBias + tzi.Bias;
  3296.   if (tzBias > 0)
  3297.     rVal = CLTimeSpan(0, 0, (WORD) tzBias, 0);
  3298.   else
  3299.   {
  3300.     rVal = CLTimeSpan(0, 0, (WORD) -tzBias, 0);
  3301.     rVal.Negate();
  3302.   }
  3303.   return rVal;
  3304. }
  3305.  
  3306. CString CLDate::DaylightName()
  3307. {
  3308.   TIME_ZONE_INFORMATION tzi;
  3309.   BOOL bSuccess = (::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  3310.   ASSERT(bSuccess);
  3311.   return tzi.DaylightName;
  3312. }
  3313.  
  3314. CString CLDate::StandardName()
  3315. {
  3316.   TIME_ZONE_INFORMATION tzi;
  3317.   BOOL bSuccess = (::GetTimeZoneInformation(&tzi) != TIME_ZONE_ID_UNKNOWN);
  3318.   ASSERT(bSuccess);
  3319.   return tzi.StandardName;
  3320. }
  3321.  
  3322. #ifdef _DEBUG
  3323. BOOL CLDate::SetDoConstructorAsserts(BOOL bDoAsserts)
  3324. {
  3325.   BOOL bOldDoAsserts = sm_bDoAsserts;
  3326.   sm_bDoAsserts = bDoAsserts;
  3327.   return bOldDoAsserts;
  3328. }
  3329. #endif            
  3330.  
  3331. CDate CLDate::GetCDate() const
  3332. {
  3333.   CDate rVal;
  3334.   if (IsValid())
  3335.     rVal = CDate(((LONG) (m_nSeconds/86400))-2000000000L, CDate::EPOCH_GREG);
  3336.  
  3337.   return rVal;
  3338. }
  3339.  
  3340. CLTimeOfDay CLDate::GetCLTimeOfDay() const
  3341. {
  3342.   CLTimeOfDay rVal;
  3343.   if (IsValid())
  3344.   {
  3345.     __int64 nSeconds = m_nSeconds - __int64(GetCDate().GetValue())*86400;
  3346.     rVal = CLTimeOfDay((DWORD) nSeconds);
  3347.   }
  3348.   return rVal;
  3349. }
  3350.  
  3351. DateLS CLDate::GetDate() const
  3352. {
  3353.   DateLS rVal;
  3354.   DateS ds = GetCDate().GetDate();
  3355.  
  3356.   rVal.lYear = ds.lYear; 
  3357.   rVal.wMonth = ds.wMonth;
  3358.   rVal.wDay = ds.wDay;
  3359.   rVal.wWday = ds.wWday;
  3360.   rVal.wYday = ds.wYday;
  3361.   rVal.ct = ds.ct;
  3362.   rVal.tf = m_TimeFrame;
  3363.   CLTimeOfDay tod(GetCLTimeOfDay());
  3364.   rVal.wHour = tod.GetHour();
  3365.   rVal.wMinute = tod.GetMinute();
  3366.   rVal.wSecond = tod.GetSecond();
  3367.   
  3368.   return rVal;
  3369. };
  3370.  
  3371. SYSTEMTIME CLDate::GetSYSTEMTIME() const
  3372. {
  3373.   SYSTEMTIME s = GetCDate().GetSYSTEMTIME();
  3374.   CLTimeOfDay tod(GetCLTimeOfDay());
  3375.  
  3376.   s.wHour = tod.GetHour();
  3377.   s.wMinute = tod.GetMinute();
  3378.   s.wSecond = tod.GetSecond();
  3379.   s.wMilliseconds = 0;
  3380.  
  3381.   return s;
  3382. }                         
  3383.  
  3384. tm CLDate::GetTM()
  3385. {
  3386.   AssertValid();
  3387.  
  3388.   tm rVal;                
  3389.   rVal.tm_sec   = 0;
  3390.   rVal.tm_min   = 0;
  3391.   rVal.tm_hour  = 0;
  3392.   rVal.tm_mday  = 0;
  3393.   rVal.tm_mon   = 0;
  3394.   rVal.tm_year  = 0;
  3395.   rVal.tm_wday  = 0;
  3396.   rVal.tm_yday  = 0;
  3397.   rVal.tm_isdst = 0;
  3398.  
  3399.   DateLS ds = GetDate();
  3400.  
  3401.   long MinYear = 1900L + LONG_MIN;
  3402.   long MaxYear = LONG_MAX;
  3403.  
  3404.   //handle range errors
  3405.   if ((ds.lYear < MinYear) || (ds.lYear > MaxYear))
  3406.   {
  3407.     ASSERT(FALSE);
  3408.     return rVal;
  3409.   }
  3410.   
  3411.   rVal.tm_hour = ds.wHour;
  3412.   rVal.tm_min = ds.wMinute;
  3413.   rVal.tm_sec = ds.wSecond;
  3414.   rVal.tm_year = (int) (ds.lYear - 1900L);
  3415.   rVal.tm_mon = ds.wMonth - 1;  //tm struct uses 0 based indices
  3416.   rVal.tm_wday = ds.wWday - 1;  //tm struct uses 0 based indices
  3417.   rVal.tm_mday = ds.wDay;
  3418.   rVal.tm_wday = ds.wYday - 1; //Returns days since Jan 1
  3419.   rVal.tm_isdst = IsDST();
  3420.               
  3421.   return rVal;
  3422. }
  3423.  
  3424. TimeFrame CLDate::GetTimeFrame() const
  3425. {
  3426.   AssertValid();
  3427.   return m_TimeFrame;
  3428. }
  3429.  
  3430. TimeFrame CLDate::SetTimeFrame(TimeFrame tf)
  3431. {
  3432.   if (tf == m_TimeFrame)  //quick return
  3433.     return tf;
  3434.     
  3435.   TimeFrame OldTF = m_TimeFrame;   
  3436.  
  3437.   switch (m_TimeFrame)
  3438.   {
  3439.     case LOCAL:
  3440.     {
  3441.       switch (tf)
  3442.       {
  3443.         case UCT:
  3444.         {
  3445.           //pretend that timeframe is UCT to avoid recursion in the arithmetic
  3446.           m_TimeFrame = UCT;
  3447.  
  3448.           *this += TimezoneBias();
  3449.           if (DST())
  3450.             *this += DaylightBias();
  3451.           break;
  3452.         }
  3453.         case ET:
  3454.         {
  3455.           SetTimeFrame(UCT);
  3456.           SetTimeFrame(ET);
  3457.           break;
  3458.         }
  3459.         default: ASSERT(FALSE);
  3460.       }
  3461.       break;
  3462.     }
  3463.     case ET:
  3464.     {
  3465.       switch (tf)
  3466.       {
  3467.         case UCT:
  3468.         {
  3469.           *this -= DeltaT();
  3470.           break;
  3471.         }
  3472.         case LOCAL:
  3473.         {
  3474.           SetTimeFrame(UCT);
  3475.           SetTimeFrame(LOCAL);
  3476.           break;
  3477.         }
  3478.         default: ASSERT(FALSE);
  3479.       }
  3480.       break;
  3481.     }
  3482.     case UCT:
  3483.     {
  3484.       switch (tf)
  3485.       {
  3486.         case LOCAL:
  3487.         {
  3488.           *this -= TimezoneBias();
  3489.           if (DST())
  3490.           {
  3491.             *this -= DaylightBias();
  3492.             sm_bIsDst = TRUE;
  3493.           }
  3494.           else
  3495.             sm_bIsDst = FALSE;
  3496.           break;
  3497.         }
  3498.         case ET:
  3499.         {
  3500.           *this += DeltaT();
  3501.           break;
  3502.         }
  3503.         default: ASSERT(FALSE);
  3504.       }
  3505.       break;
  3506.     }
  3507.  
  3508.     default: ASSERT(FALSE);
  3509.   }
  3510.  
  3511.   m_TimeFrame = tf;
  3512.   return OldTF;
  3513. };
  3514.  
  3515. BOOL CLDate::IsDST()
  3516. {
  3517.   AssertValid();
  3518.   BOOL rVal;  
  3519.   TimeFrame OldTF = GetTimeFrame();
  3520.   if (OldTF != LOCAL)
  3521.   {
  3522.     SetTimeFrame(LOCAL);
  3523.     rVal = sm_bIsDst;
  3524.   }
  3525.   else
  3526.     rVal = DST();
  3527.   return rVal;
  3528. }
  3529.  
  3530. BOOL CLDate::DST()
  3531. {
  3532.   AssertValid();
  3533.   BOOL rVal = TRUE;
  3534.   TIME_ZONE_INFORMATION tzi;
  3535.   DWORD dwTZI = ::GetTimeZoneInformation(&tzi);
  3536.   ASSERT(dwTZI != TIME_ZONE_ID_UNKNOWN);
  3537.  
  3538.   long lYear = GetCDate().GetYear();
  3539.  
  3540.   //SYSTEMTIME can only accomadate a WORD sized year
  3541.   //so we always return FALSE if outside of this range
  3542.   if ((lYear > SHRT_MAX) || (lYear < 0))
  3543.     rVal = FALSE;
  3544.  
  3545.   if (rVal)
  3546.   {
  3547.     TimeFrame OldTF = m_TimeFrame;
  3548.     m_TimeFrame = UCT;
  3549.  
  3550.     BOOL bUseDayOfWeek = FALSE;
  3551.     if (tzi.DaylightDate.wYear == 0)
  3552.     {
  3553.       bUseDayOfWeek = TRUE;
  3554.       tzi.DaylightDate.wYear = (WORD) lYear;
  3555.     }
  3556.  
  3557.     CLDate BeginDST(tzi.DaylightDate, UCT, bUseDayOfWeek);
  3558.  
  3559. #ifdef _DEBUG
  3560.     CString s = BeginDST.Format();
  3561. #endif
  3562.  
  3563.     bUseDayOfWeek = FALSE;
  3564.     if (tzi.StandardDate.wYear == 0)
  3565.     {
  3566.       bUseDayOfWeek = TRUE;
  3567.       tzi.StandardDate.wYear = (WORD) lYear;
  3568.     }
  3569.  
  3570.     CLDate EndDST(tzi.StandardDate, UCT, bUseDayOfWeek);
  3571. #ifdef _DEBUG
  3572.     s = EndDST.Format();
  3573. #endif
  3574.   
  3575.     rVal = rVal && (*this >= BeginDST && *this < EndDST);
  3576.  
  3577.     m_TimeFrame = OldTF;
  3578.   }
  3579.   
  3580.   return rVal;
  3581. }
  3582.  
  3583. CString CLDate::GetStringTimeFrame() const
  3584. {
  3585.   CString rVal;
  3586.   switch (m_TimeFrame)
  3587.   {
  3588.     case UCT:   
  3589.       if (!rVal.LoadString(IDS_UCT))
  3590.         ASSERT(FALSE);
  3591.       break;
  3592.     case ET:  
  3593.       if (!rVal.LoadString(IDS_ET))
  3594.         ASSERT(FALSE);
  3595.       break;
  3596.     case LOCAL: 
  3597.       if (!rVal.LoadString(IDS_LOCAL))
  3598.         ASSERT(FALSE);
  3599.       break;
  3600.     default:  
  3601.       ASSERT(FALSE);
  3602.       break;
  3603.   }
  3604.   return rVal;
  3605. }
  3606.  
  3607. void CLDate::AddYear(int Years)
  3608. {
  3609.   AssertValid();
  3610.   CDate Date(GetCDate());
  3611.   CLTimeOfDay Tod(GetCLTimeOfDay());
  3612.   Date.AddYear(Years);
  3613.   Set(Date, Tod, m_TimeFrame);
  3614. }
  3615.  
  3616. void CLDate::AddMonth(int Months)
  3617. {
  3618.   AssertValid();
  3619.   CDate Date(GetCDate());
  3620.   CLTimeOfDay Tod(GetCLTimeOfDay());
  3621.   Date.AddMonth(Months);
  3622.   Set(Date, Tod, m_TimeFrame);
  3623. }
  3624.  
  3625. void CLDate::AddWeek(int Weeks)
  3626. {
  3627.   AssertValid();
  3628.  
  3629.   CDate Date(GetCDate());
  3630.   CLTimeOfDay Tod(GetCLTimeOfDay());
  3631.   Date.AddWeek(Weeks);
  3632.   Set(Date, Tod, m_TimeFrame);
  3633. }
  3634.  
  3635. BOOL CLDate::IsValid() const
  3636. {
  3637.   return m_bValid;
  3638. }
  3639.  
  3640. CLTimeSpan CLDate::DeltaT()
  3641. {
  3642.   AssertValid();
  3643.   return DeltaT(*this);
  3644. }
  3645.  
  3646. CLDate& CLDate::operator=(const CLDate& d) 
  3647. {
  3648.   m_TimeFrame = d.m_TimeFrame;
  3649.   m_nSeconds = d.m_nSeconds;
  3650.   m_bValid = d.m_bValid;
  3651.   return *this;
  3652. }              
  3653.  
  3654. CLDate CLDate::operator+(const CLTimeSpan& TimeSpan)
  3655. {
  3656.   AssertValid();
  3657.   TimeSpan.AssertValid();
  3658.  
  3659.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3660.   TimeFrame OldTF = GetTimeFrame();
  3661.   if (GetTimeFrame() == LOCAL)
  3662.     SetTimeFrame(UCT);
  3663.  
  3664.   CLDate rVal;
  3665.   rVal.m_nSeconds = m_nSeconds + TimeSpan.m_nSeconds;
  3666.   rVal.m_TimeFrame = m_TimeFrame;
  3667.   rVal.m_bValid = TRUE;
  3668.  
  3669.   SetTimeFrame(OldTF);
  3670.   rVal.SetTimeFrame(OldTF);
  3671.  
  3672.   return rVal;
  3673. }
  3674.  
  3675. CLTimeSpan CLDate::operator-(CLDate& ld)
  3676. {
  3677.   AssertValid();
  3678.   ld.AssertValid();
  3679.  
  3680.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3681.   TimeFrame OldTF1 = GetTimeFrame();
  3682.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3683.  
  3684.   BOOL bTimeFrameChangeRequired = ( (OldTF1 == LOCAL) && (OldTF2 != LOCAL) ||
  3685.                                     (OldTF1 != LOCAL) && (OldTF2 == LOCAL) );
  3686.   if (bTimeFrameChangeRequired)
  3687.   {
  3688.     TimeFrame OldTF1 = SetTimeFrame(UCT);
  3689.     TimeFrame OldTF2 = ld.SetTimeFrame(UCT);
  3690.   }
  3691.  
  3692.   __int64 s = m_nSeconds - ld.m_nSeconds;
  3693.   CLTimeSpan rVal(s);
  3694.  
  3695.   SetTimeFrame(OldTF1);
  3696.   ld.SetTimeFrame(OldTF2);
  3697.  
  3698.   return rVal;
  3699. }
  3700.  
  3701. CLDate CLDate::operator-(const CLTimeSpan& TimeSpan)
  3702. {
  3703.   AssertValid();
  3704.   TimeSpan.AssertValid();
  3705.  
  3706.   //Because LOCAL Time is not a continous timeframe convert if necessary
  3707.   TimeFrame OldTF = GetTimeFrame();
  3708.   if (GetTimeFrame() == LOCAL)
  3709.     SetTimeFrame(UCT);
  3710.  
  3711.   __int64 s = m_nSeconds - TimeSpan.m_nSeconds;
  3712.   CLDate rVal;
  3713.   rVal.m_nSeconds = s;
  3714.   rVal.m_TimeFrame = m_TimeFrame;
  3715.   rVal.m_bValid = TRUE;
  3716.  
  3717.   SetTimeFrame(OldTF);
  3718.  
  3719.   return rVal;
  3720. }
  3721.  
  3722. CLDate& CLDate::operator+=(const CLTimeSpan& TimeSpan)
  3723. {
  3724.   *this = *this + TimeSpan;
  3725.   return *this;
  3726. }
  3727.  
  3728. CLDate& CLDate::operator-=(const CLTimeSpan& TimeSpan)
  3729. {
  3730.   *this = *this - TimeSpan;
  3731.   return *this;
  3732. }
  3733.  
  3734. CLDate& CLDate::operator++()
  3735. {
  3736.   AssertValid();
  3737.   m_nSeconds += 86400;
  3738.   return *this;
  3739. }
  3740.  
  3741. CLDate& CLDate::operator--()
  3742. {
  3743.   AssertValid();
  3744.   m_nSeconds -= 86400;
  3745.   return *this;
  3746. }
  3747.   
  3748. BOOL CLDate::operator==(CLDate& ld)
  3749. {
  3750.   AssertValid();
  3751.   
  3752.   //Match the two instances timeframes if neccessary
  3753.   TimeFrame OldTF1 = GetTimeFrame();
  3754.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3755.  
  3756.   BOOL bTimeFrameChangeRequired = (OldTF1 != OldTF2);
  3757.   if (bTimeFrameChangeRequired)
  3758.   {
  3759.     TimeFrame OldTF1 = SetTimeFrame(UCT);
  3760.     TimeFrame OldTF2 = ld.SetTimeFrame(UCT);
  3761.   }
  3762.  
  3763.   BOOL rVal = (m_nSeconds == ld.m_nSeconds);
  3764.  
  3765.   SetTimeFrame(OldTF1);
  3766.   ld.SetTimeFrame(OldTF2);
  3767.  
  3768.   return rVal;
  3769. }
  3770.  
  3771. BOOL CLDate::operator>(CLDate& ld)
  3772. {
  3773.   AssertValid();
  3774.  
  3775.   //Match the two instances timeframes if neccessary
  3776.   TimeFrame OldTF1 = GetTimeFrame();
  3777.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3778.   BOOL bTimeFrameChangeRequired = (OldTF1 != OldTF2);
  3779.   if (bTimeFrameChangeRequired)
  3780.   {
  3781.     TimeFrame OldTF1 = SetTimeFrame(UCT);
  3782.     TimeFrame OldTF2 = ld.SetTimeFrame(UCT);
  3783.   }
  3784.  
  3785.   BOOL rVal = (m_nSeconds > ld.m_nSeconds);
  3786.  
  3787.   SetTimeFrame(OldTF1);
  3788.   ld.SetTimeFrame(OldTF2);
  3789.  
  3790.   return rVal;
  3791. }
  3792.  
  3793. BOOL CLDate::operator>=(CLDate& ld)
  3794. {
  3795.   AssertValid();
  3796.  
  3797.   //Match the two instances timeframes if neccessary
  3798.   TimeFrame OldTF1 = GetTimeFrame();
  3799.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3800.   BOOL bTimeFrameChangeRequired = (OldTF1 != OldTF2);
  3801.   if (bTimeFrameChangeRequired)
  3802.   {
  3803.     TimeFrame OldTF1 = SetTimeFrame(UCT);
  3804.     TimeFrame OldTF2 = ld.SetTimeFrame(UCT);
  3805.   }
  3806.  
  3807.   BOOL rVal = (m_nSeconds >= ld.m_nSeconds);
  3808.  
  3809.   SetTimeFrame(OldTF1);
  3810.   ld.SetTimeFrame(OldTF2);
  3811.  
  3812.   return rVal;
  3813. }
  3814.  
  3815. BOOL CLDate::operator<(CLDate& ld)
  3816. {
  3817.   AssertValid();
  3818.  
  3819.   //Match the two instances timeframes if neccessary
  3820.   TimeFrame OldTF1 = GetTimeFrame();
  3821.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3822.   BOOL bTimeFrameChangeRequired = (OldTF1 != OldTF2);
  3823.   if (bTimeFrameChangeRequired)
  3824.   {
  3825.     TimeFrame OldTF1 = SetTimeFrame(UCT);
  3826.     TimeFrame OldTF2 = ld.SetTimeFrame(UCT);
  3827.   }
  3828.  
  3829.   BOOL rVal = (m_nSeconds < ld.m_nSeconds);
  3830.  
  3831.   SetTimeFrame(OldTF1);
  3832.   ld.SetTimeFrame(OldTF2);
  3833.  
  3834.   return rVal;
  3835. }
  3836.  
  3837. BOOL CLDate::operator<=(CLDate& ld)
  3838. {
  3839.   AssertValid();
  3840.  
  3841.   //Match the two instances timeframes if neccessary
  3842.   TimeFrame OldTF1 = GetTimeFrame();
  3843.   TimeFrame OldTF2 = ld.GetTimeFrame();
  3844.   BOOL bTimeFrameChangeRequired = (OldTF1 != OldTF2);
  3845.   if (bTimeFrameChangeRequired)
  3846.   {
  3847.     TimeFrame OldTF1 = SetTimeFrame(UCT);
  3848.     TimeFrame OldTF2 = ld.SetTimeFrame(UCT);
  3849.   }
  3850.  
  3851.   BOOL rVal = (m_nSeconds <= ld.m_nSeconds);
  3852.  
  3853.   SetTimeFrame(OldTF1);
  3854.   ld.SetTimeFrame(OldTF2);
  3855.  
  3856.   return rVal;
  3857. }
  3858.  
  3859. BOOL CLDate::operator!=(CLDate& ld)
  3860. {
  3861.   AssertValid();
  3862.   return !operator==(ld);
  3863. }
  3864.  
  3865. #ifdef _DEBUG
  3866. void CLDate::AssertValid() const       
  3867. {
  3868.   CObject::AssertValid();
  3869.   ASSERT(IsValid());
  3870. }
  3871. #endif
  3872.  
  3873. #ifdef _DEBUG
  3874. void CLDate::Dump(CDumpContext& dc) const
  3875. {
  3876.   CObject::Dump(dc);
  3877.   if (IsValid())
  3878.     dc << Format() << _T("\n");
  3879.   else
  3880.     dc << _T("Invalid state\n");
  3881. }
  3882. #endif           
  3883.  
  3884. /*
  3885. CString CLDate::Format(const CString& sFormat=CDate::m_sDefaultFormat) const
  3886. %a    Abbreviated weekday name
  3887. %A    Full weekday name
  3888. %b    Abbreviated month name
  3889. %B    Full month name
  3890. %d    Day of month as decimal number (01 - 31)
  3891. %j    Day of year as decimal number (001 - 366)
  3892. %m    Month as decimal number (01 - 12)
  3893. %P    AM / PM indicator
  3894. %U    Week of year as decimal number
  3895. %w    Weekday as decimal number (1 - 7; Sunday is 1)
  3896. %x    Date representation for current locale,  namely 
  3897.         Date representation + " " + Time Representation for current locale
  3898. %y    Year without century, as decimal number (00 - 99)
  3899. %Y    Year with century, as decimal number
  3900. %c    Year displayed using C.E.(Current Epoch) / B.C.E (Before Current Epoch) convention e.g. -1023 = 1022 BCE
  3901. %t    String containing a representation of the TimeFrame ("UCT", "LOCAL" or "ET")
  3902.  
  3903. %H    Hours in the day
  3904. %h    12 Hour format Hours in (00 - 12)
  3905. %M    Minutes in the hour
  3906. %S    Seconds in the minute
  3907. %F    MilliSeconds in the second
  3908. %%    Percent sign        
  3909.  
  3910.  
  3911. //may also need to include full windows escape character
  3912.  
  3913. %%    Percent sign
  3914.  
  3915. As in the printf function, the # flag may prefix any formatting code. 
  3916. In that case, the meaning of the format code is changed as follows.
  3917.  
  3918. Format Code Meaning
  3919. %#x Long date representation, appropriate to current locale, namely
  3920.       Long Date representation + " " + Time Representation for current locale
  3921.  
  3922.  
  3923. %#d, %#j, %#m, %#U, %#w, %#y, %#H, %#h, %#M, %#S  Remove leading zeros (if any).
  3924. */
  3925. CString CLDate::Format(const CString& sFormat) const
  3926. { 
  3927.   CString rVal;
  3928.   if (IsValid())
  3929.   {
  3930.     CString sBuffer;
  3931.     int sFmtLength = sFormat.GetLength();
  3932.  
  3933.     for (int i=0; i<sFmtLength; i++)
  3934.     {
  3935.       TCHAR c = sFormat.GetAt(i);
  3936.       if (c == '%')
  3937.       {
  3938.         ++i;
  3939.         if (i < sFmtLength)
  3940.         {
  3941.           c = sFormat.GetAt(i);
  3942.           switch (c)
  3943.           {
  3944.             case _T('H'):
  3945.             {
  3946.               sBuffer.Format(_T("%.02d"), GetCLTimeOfDay().GetHour());
  3947.               rVal += sBuffer;
  3948.               break;
  3949.             }
  3950.             case _T('h'):
  3951.             {
  3952.               sBuffer.Format(_T("%.02d"), GetCLTimeOfDay().GetAMPMHour());
  3953.               rVal += sBuffer;
  3954.               break;
  3955.             }
  3956.             case _T('M'):
  3957.             {
  3958.               sBuffer.Format(_T("%.02d"), GetCLTimeOfDay().GetMinute());
  3959.               rVal += sBuffer;
  3960.               break;
  3961.             }
  3962.             case _T('P'):
  3963.             {
  3964.               rVal += GetCLTimeOfDay().GetAMPMString();
  3965.               break;
  3966.             }
  3967.             case _T('S'):
  3968.             {
  3969.               sBuffer.Format(_T("%.02d"), GetCLTimeOfDay().GetSecond());
  3970.               rVal += sBuffer;
  3971.               break;
  3972.             }
  3973.             case _T('a'):
  3974.             {
  3975.               rVal += GetCDate().GetAbrStringDayOfWeek();
  3976.               break;
  3977.             }
  3978.             case _T('A'):
  3979.             {
  3980.               rVal += GetCDate().GetFullStringDayOfWeek();
  3981.               break;
  3982.             }
  3983.             case _T('b'):
  3984.             {
  3985.               rVal += GetCDate().GetAbrStringMonth();
  3986.               break;
  3987.             }
  3988.             case _T('B'):
  3989.             {
  3990.               rVal += GetCDate().GetFullStringMonth();
  3991.               break;
  3992.             }
  3993.             case _T('c'):
  3994.             {
  3995.               rVal += GetCDate().GetStringCEBCEYear();
  3996.               break;
  3997.             }
  3998.             case _T('d'):
  3999.             {
  4000.               sBuffer.Format(_T("%.02d"), GetCDate().GetDay());
  4001.               rVal += sBuffer;
  4002.               break;
  4003.             }
  4004.             case _T('j'):
  4005.             {
  4006.               sBuffer.Format(_T("%.03d"), GetCDate().DaysSinceJan0());
  4007.               rVal += sBuffer;
  4008.               break;
  4009.             }
  4010.             case _T('m'):
  4011.             {
  4012.               sBuffer.Format(_T("%.02d"), GetCDate().GetMonth());
  4013.               rVal += sBuffer;
  4014.               break;
  4015.             }
  4016.             case _T('t'):
  4017.             {
  4018.               rVal += GetStringTimeFrame();
  4019.               break;
  4020.             }
  4021.             case _T('U'):
  4022.             {
  4023.               sBuffer.Format(_T("%.02d"), GetCDate().GetWeekOfYear());
  4024.               rVal += sBuffer;
  4025.               break;
  4026.             }
  4027.             case _T('w'):
  4028.             {
  4029.               sBuffer.Format(_T("%d"), GetCDate().GetDayOfWeek());
  4030.               rVal += sBuffer;
  4031.               break;
  4032.             }
  4033.             case _T('x'):
  4034.             {
  4035.               rVal += GetCDate().Format(_T("%x")) + _T(" ") + GetCLTimeOfDay().Format(_T("%x"));
  4036.               break;
  4037.             }
  4038.             case _T('y'):
  4039.             {
  4040.               LONG Year = GetCDate().GetYear();
  4041.               sBuffer.Format(_T("%.02d"), GetCDate().Get2DigitYear());
  4042.               rVal += sBuffer;
  4043.               break;
  4044.             }
  4045.             case _T('Y'):
  4046.             {
  4047.               sBuffer.Format(_T("%ld"), GetCDate().GetYear());
  4048.               rVal += sBuffer;
  4049.               break;
  4050.             }
  4051.             case _T('#'):
  4052.             {
  4053.               if (i < sFmtLength)
  4054.               {
  4055.                 ++i;
  4056.                 c = sFormat.GetAt(i);
  4057.                 switch (c)
  4058.                 {
  4059.                   case _T('d'):
  4060.                   {
  4061.                     sBuffer.Format(_T("%d"), GetCDate().GetDay());
  4062.                     rVal += sBuffer;
  4063.                     break;
  4064.                   }
  4065.                   case _T('j'):
  4066.                   {
  4067.                     sBuffer.Format(_T("%d"), GetCDate().DaysSinceJan0());
  4068.                     rVal += sBuffer;
  4069.                     break;
  4070.                   }
  4071.                   case _T('m'):
  4072.                   {
  4073.                     sBuffer.Format(_T("%d"), GetCDate().GetMonth());
  4074.                     rVal += sBuffer;
  4075.                     break;
  4076.                   }
  4077.                   case _T('U'):
  4078.                   {
  4079.                     sBuffer.Format(_T("%d"), GetCDate().GetWeekOfYear());
  4080.                     rVal += sBuffer;
  4081.                     break;
  4082.                   }
  4083.                   case _T('x'):
  4084.                   {
  4085.                     rVal += GetCDate().Format(_T("%#x")) + _T(" ") + GetCLTimeOfDay().Format(_T("%x"));
  4086.                     break;
  4087.                   }
  4088.                   case _T('y'):
  4089.                   {
  4090.                     LONG Year = GetCDate().GetYear();
  4091.                     sBuffer.Format(_T("%d"), GetCDate().Get2DigitYear());
  4092.                     rVal += sBuffer;
  4093.                     break;
  4094.                   }
  4095.                   case _T('H'):
  4096.                   {
  4097.                     sBuffer.Format(_T("%d"), GetCLTimeOfDay().GetHour());
  4098.                     rVal += sBuffer;
  4099.                     break;
  4100.                   }
  4101.                   case _T('h'):
  4102.                   {
  4103.                     sBuffer.Format(_T("%d"), GetCLTimeOfDay().GetAMPMHour());
  4104.                     rVal += sBuffer;
  4105.                     break;
  4106.                   }
  4107.                   case _T('M'):
  4108.                   {
  4109.                     sBuffer.Format(_T("%d"), GetCLTimeOfDay().GetMinute());
  4110.                     rVal += sBuffer;
  4111.                     break;
  4112.                   }
  4113.                   case _T('S'):
  4114.                   {
  4115.                     sBuffer.Format(_T("%d"), GetCLTimeOfDay().GetSecond());
  4116.                     rVal += sBuffer;
  4117.                     break;
  4118.                   }
  4119.                   default:
  4120.                   {
  4121.                     rVal += c;
  4122.                     break;
  4123.                   }
  4124.                 }
  4125.               }
  4126.               break;
  4127.             }
  4128.             default:
  4129.             {
  4130.               rVal += c;
  4131.               break;
  4132.             }
  4133.           }
  4134.         }
  4135.       }
  4136.       else
  4137.       {
  4138.         rVal += c;
  4139.       }
  4140.     }
  4141.   }
  4142.  
  4143.   return rVal;
  4144. }
  4145.  
  4146. //Format according to the short date and time format as specified by the control panel
  4147. CString CLDate::Format(DWORD dwFlags) const
  4148. {
  4149.   //let the component parts of the long date handle their formatting
  4150.   CDate Date = GetCDate();
  4151.   CLTimeOfDay Tod = GetCLTimeOfDay();
  4152.  
  4153.   if (dwFlags & DTF_NOTIMEFRAME)
  4154.     return Date.Format() + _T(" ") + Tod.Format(dwFlags);
  4155.   else
  4156.     return Date.Format() + _T(" ") + Tod.Format(dwFlags) + _T(" ") + Format(_T("%t"));
  4157. }
  4158.  
  4159. void CLDate::Serialize(CArchive& ar)
  4160. {
  4161.   CObject::Serialize(ar);
  4162.  
  4163.   if (ar.IsStoring())
  4164.   {
  4165.     ar << m_nSeconds;
  4166.     ar << (WORD) m_TimeFrame;
  4167.     ar << m_bValid;
  4168.   }
  4169.   else
  4170.   {
  4171.     ar >> m_nSeconds;
  4172.     ar >> (WORD&) m_TimeFrame;
  4173.     ar >> m_bValid;
  4174.   }
  4175. }
  4176.  
  4177. ostream& operator<<(ostream& os, const CLDate& ld)
  4178. {
  4179.   return os << ld.Format();
  4180. }
  4181.  
  4182. CArchive& operator<<(CArchive& ar, CLDate& ld)
  4183. {
  4184.   ASSERT(ar.IsStoring());
  4185.   ld.Serialize(ar);
  4186.   return ar;
  4187. }
  4188.  
  4189. CArchive& operator>>(CArchive& ar, CLDate& ld)
  4190. {
  4191.   ASSERT(!ar.IsStoring());
  4192.   ld.Serialize(ar);
  4193.   return ar;
  4194. }
  4195.  
  4196.  
  4197.  
  4198.